;;;;	-------------------------------
;;;;	Copyright (c) Corman Technologies Inc.
;;;;	See LICENSE.txt for license information.
;;;;	-------------------------------
;;;;
;;;;	File:		hyperspec.lisp
;;;;	Contents:	Links to Kent Pitman's ANSI Common Lisp Hyperspec
;;;;	History:	11/20/96  RGC  Created.
;;;;

(in-package "CORMANLISP")
(export 'HYPERSPEC)

;; change this to point to the correct place on your system if necessary
;; for example: "c:/hyperspec/"
;;
;(unless *hyperspec-local-path*
;	(setf *hyperspec-local-path* 
;		(concatenate 'string "file://" pl:*cormanlisp-directory* "/HyperSpec/")))

(defvar *hyperspec-version* 7)		;; we support either 4 or 6-7

(defvar *hyperspec-internet-path* "www.lispworks.com/documentation/HyperSpec/")

(defvar *use-external-browser* nil)

(defun win::install-hyperspec () #| place holder |#)

(defun hyperspec (sym)
    ;; first time, may need to install hyperspec
    (if *hyperspec-local-path*
        (unless (or (stringp *hyperspec-local-path*)(pathnamep *hyperspec-local-path*))
            ;; install hyperspec in a separate process
            (let ((save-dir (current-directory)))
                (setf (current-directory) *cormanlisp-directory*)
                (win:shell
                    (concatenate 'string
                        "clconsole.exe"
                        " -execute "
                        "utilities\\install-hyperspec.lisp"))
                (setf (current-directory) save-dir))
            (setf *hyperspec-local-path*
                (if (probe-file (merge-pathnames "HyperSpec/Front/Contents.htm"))
                    (merge-pathnames "HyperSpec/")
                    nil))))
    
	(let* ((doc-list (gethash sym cl::*documentation-registry*))
		   (hyperspec-ref (getf doc-list ':hyperspec))
		   (path (if *hyperspec-local-path* 
					*hyperspec-local-path* 
					*hyperspec-internet-path*))
	       (url (concatenate 'string
				 (when *hyperspec-local-path* "file:///") ; intriguingly needed for some browsers (at least Chrome and Firefox).
                                 (namestring path) 
                                 "Body/" 
                                 hyperspec-ref 
                                 (if (= *hyperspec-version* 4) ".html" ""))))
		(if hyperspec-ref
		    (if *use-external-browser* (win::shell-execute url "") (cl::display-url url))
		    (error "The symbol ~A does not have a hyperspec location registered" sym))))
 
 
(defvar hyperspec-refs 
	(if (= *hyperspec-version* 4)
		#(
&ALLOW-OTHER-KEYS                          "sec_3-4-1"
&AUX                                       "sec_3-4-1"
&BODY                                      "sec_3-4-4"
&ENVIRONMENT                               "sec_3-4-4"
&KEY                                       "sec_3-4-1"
&OPTIONAL                                  "sec_3-4-1"
&REST                                      "sec_3-4-1"
&WHOLE                                     "sec_3-4-4"
*                                          "any_st"
**                                         "var_stcm_ststcm_ststst"
***                                        "var_stcm_ststcm_ststst"
*BREAK-ON-SIGNALS*                         "var_stbreak-on-signalsst"
*COMPILE-FILE-PATHNAME*                    "var_stcompile_e-truenamest"
*COMPILE-FILE-TRUENAME*                    "var_stcompile_e-truenamest"
*COMPILE-PRINT*                            "var_stcompile_le-verbosest"
*COMPILE-VERBOSE*                          "var_stcompile_le-verbosest"
*DEBUG-IO*                                 "var_stdebug-i_ace-outputst"
*DEBUGGER-HOOK*                            "var_stdebugger-hookst"
*DEFAULT-PATHNAME-DEFAULTS*                "var_stdefault_e-defaultsst"
*ERROR-OUTPUT*                             "var_stdebug-i_ace-outputst"
*FEATURES*                                 "var_stfeaturesst"
*GENSYM-COUNTER*                           "var_stgensym-counterst"
*LOAD-PATHNAME*                            "var_stload-pa_d-truenamest"
*LOAD-PRINT*                               "var_stload-pr_ad-verbosest"
*LOAD-TRUENAME*                            "var_stload-pa_d-truenamest"
*LOAD-VERBOSE*                             "var_stload-pr_ad-verbosest"
*MACROEXPAND-HOOK*                         "var_stmacroexpand-hookst"
*MODULES*                                  "var_stmodulesst"
*PACKAGE*                                  "var_stpackagest"
*PRINT-ARRAY*                              "var_stprint-arrayst"
*PRINT-BASE*                               "var_stprint-b_rint-radixst"
*PRINT-CASE*                               "var_stprint-casest"
*PRINT-CIRCLE*                             "var_stprint-circlest"
*PRINT-ESCAPE*                             "var_stprint-escapest"
*PRINT-GENSYM*                             "var_stprint-gensymst"
*PRINT-LENGTH*                             "var_stprint-l_int-lengthst"
*PRINT-LEVEL*                              "var_stprint-l_int-lengthst"
*PRINT-LINES*                              "var_stprint-linesst"
*PRINT-MISER-WIDTH*                        "var_stprint-miser-widthst"
*PRINT-PPRINT-DISPATCH*                    "var_stprint-p_t-dispatchst"
*PRINT-PRETTY*                             "var_stprint-prettyst"
*PRINT-RADIX*                              "var_stprint-b_rint-radixst"
*PRINT-READABLY*                           "var_stprint-readablyst"
*PRINT-RIGHT-MARGIN*                       "var_stprint-right-marginst"
*QUERY-IO*                                 "var_stdebug-i_ace-outputst"
*RANDOM-STATE*                             "var_strandom-statest"
*READ-BASE*                                "var_stread-basest"
*READ-DEFAULT-FLOAT-FORMAT*                "var_stread-de_oat-formatst"
*READ-EVAL*                                "var_stread-evalst"
*READ-SUPPRESS*                            "var_stread-suppressst"
*READTABLE*                                "var_streadtablest"
*STANDARD-INPUT*                           "var_stdebug-i_ace-outputst"
*STANDARD-OUTPUT*                          "var_stdebug-i_ace-outputst"
*TERMINAL-IO*                              "var_stterminal-iost"
*TRACE-OUTPUT*                             "var_stdebug-i_ace-outputst"
+                                          "any_pl"
++                                         "var_plcm_plplcm_plplpl"
+++                                        "var_plcm_plplcm_plplpl"
-                                          "any_-"
/                                          "any_sl"
//                                         "var_slcm_slslcm_slslsl"
///                                        "var_slcm_slslcm_slslsl"
/=                                         "fun_eqcm_sleq__lteqcm_gteq"
1+                                         "fun_1plcm_1-"
1-                                         "fun_1plcm_1-"
<                                          "fun_eqcm_sleq__lteqcm_gteq"
<=                                         "fun_eqcm_sleq__lteqcm_gteq"
=                                          "fun_eqcm_sleq__lteqcm_gteq"
>                                          "fun_eqcm_sleq__lteqcm_gteq"
>=                                         "fun_eqcm_sleq__lteqcm_gteq"
ABORT                                      "any_abort"
ABS                                        "fun_abs"
ACONS                                      "fun_acons"
ACOS                                       "fun_asincm_acoscm_atan"
ACOSH                                      "fun_sinhcm_co_coshcm_atanh"
ADD-METHOD                                 "stagenfun_add-method"
ADJOIN                                     "fun_adjoin"
ADJUST-ARRAY                               "fun_adjust-array"
ADJUSTABLE-ARRAY-P                         "fun_adjustable-array-p"
ALLOCATE-INSTANCE                          "stagenfun_all_ate-instance"
ALPHA-CHAR-P                               "fun_alpha-char-p"
ALPHANUMERICP                              "fun_alphanumericp"
AND                                        "any_and"
APPEND                                     "fun_append"
APPLY                                      "fun_apply"
APROPOS                                    "fun_aproposcm_apropos-list"
APROPOS-LIST                               "fun_aproposcm_apropos-list"
AREF                                       "acc_aref"
ARITHMETIC-ERROR                           "contyp_arithmetic-error"
ARITHMETIC-ERROR-OPERANDS                  "fun_arithmeti_or-operation"
ARITHMETIC-ERROR-OPERATION                 "fun_arithmeti_or-operation"
ARRAY                                      "syscla_array"
ARRAY-DIMENSION                            "fun_array-dimension"
ARRAY-DIMENSION-LIMIT                      "convar_array-_ension-limit"
ARRAY-DIMENSIONS                           "fun_array-dimensions"
ARRAY-DISPLACEMENT                         "fun_array-displacement"
ARRAY-ELEMENT-TYPE                         "fun_array-element-type"
ARRAY-HAS-FILL-POINTER-P                   "fun_array-has_ll-pointer-p"
ARRAY-IN-BOUNDS-P                          "fun_array-in-bounds-p"
ARRAY-RANK                                 "fun_array-rank"
ARRAY-RANK-LIMIT                           "convar_array-rank-limit"
ARRAY-ROW-MAJOR-INDEX                      "fun_array-row-major-index"
ARRAY-TOTAL-SIZE                           "fun_array-total-size"
ARRAY-TOTAL-SIZE-LIMIT                     "convar_array-_l-size-limit"
ARRAYP                                     "fun_arrayp"
ASH                                        "fun_ash"
ASIN                                       "fun_asincm_acoscm_atan"
ASINH                                      "fun_sinhcm_co_coshcm_atanh"
ASSERT                                     "mac_assert"
ASSOC                                      "fun_assoccm_a_assoc-if-not"
ASSOC-IF                                   "fun_assoccm_a_assoc-if-not"
ASSOC-IF-NOT                               "fun_assoccm_a_assoc-if-not"
ATAN                                       "fun_asincm_acoscm_atan"
ATANH                                      "fun_sinhcm_co_coshcm_atanh"
ATOM                                       "any_atom"
BASE-CHAR                                  "typ_base-char"
BASE-STRING                                "typ_base-string"
BIGNUM                                     "typ_bignum"
BIT                                        "any_bit"
BIT-AND                                    "fun_bit-andcm_c2cm_bit-xor"
BIT-ANDC1                                  "fun_bit-andcm_c2cm_bit-xor"
BIT-ANDC2                                  "fun_bit-andcm_c2cm_bit-xor"
BIT-EQV                                    "fun_bit-andcm_c2cm_bit-xor"
BIT-IOR                                    "fun_bit-andcm_c2cm_bit-xor"
BIT-NAND                                   "fun_bit-andcm_c2cm_bit-xor"
BIT-NOR                                    "fun_bit-andcm_c2cm_bit-xor"
BIT-NOT                                    "fun_bit-andcm_c2cm_bit-xor"
BIT-ORC1                                   "fun_bit-andcm_c2cm_bit-xor"
BIT-ORC2                                   "fun_bit-andcm_c2cm_bit-xor"
BIT-VECTOR                                 "syscla_bit-vector"
BIT-VECTOR-P                               "fun_bit-vector-p"
BIT-XOR                                    "fun_bit-andcm_c2cm_bit-xor"
BLOCK                                      "speope_block"
BOOLE                                      "fun_boole"
BOOLE-1                                    "convar_boole-_cm_boole-xor"
BOOLE-2                                    "convar_boole-_cm_boole-xor"
BOOLE-AND                                  "convar_boole-_cm_boole-xor"
BOOLE-ANDC1                                "convar_boole-_cm_boole-xor"
BOOLE-ANDC2                                "convar_boole-_cm_boole-xor"
BOOLE-C1                                   "convar_boole-_cm_boole-xor"
BOOLE-C2                                   "convar_boole-_cm_boole-xor"
BOOLE-CLR                                  "convar_boole-_cm_boole-xor"
BOOLE-EQV                                  "convar_boole-_cm_boole-xor"
BOOLE-IOR                                  "convar_boole-_cm_boole-xor"
BOOLE-NAND                                 "convar_boole-_cm_boole-xor"
BOOLE-NOR                                  "convar_boole-_cm_boole-xor"
BOOLE-ORC1                                 "convar_boole-_cm_boole-xor"
BOOLE-ORC2                                 "convar_boole-_cm_boole-xor"
BOOLE-SET                                  "convar_boole-_cm_boole-xor"
BOOLE-XOR                                  "convar_boole-_cm_boole-xor"
BOOLEAN                                    "typ_boolean"
BOTH-CASE-P                                "fun_upper-cas__both-case-p"
BOUNDP                                     "fun_boundp"
BREAK                                      "fun_break"
BROADCAST-STREAM                           "syscla_broadcast-stream"
BROADCAST-STREAM-STREAMS                   "fun_broadcast_ream-streams"
BUILT-IN-CLASS                             "syscla_built-in-class"
BUTLAST                                    "fun_butlastcm_nbutlast"
BYTE                                       "fun_bytecm_by_yte-position"
BYTE-POSITION                              "fun_bytecm_by_yte-position"
BYTE-SIZE                                  "fun_bytecm_by_yte-position"
CAAAAR                                     "acc_carcm_cdr_darcm_cddddr"
CAAADR                                     "acc_carcm_cdr_darcm_cddddr"
CAAAR                                      "acc_carcm_cdr_darcm_cddddr"
CAADAR                                     "acc_carcm_cdr_darcm_cddddr"
CAADDR                                     "acc_carcm_cdr_darcm_cddddr"
CAADR                                      "acc_carcm_cdr_darcm_cddddr"
CAAR                                       "acc_carcm_cdr_darcm_cddddr"
CADAAR                                     "acc_carcm_cdr_darcm_cddddr"
CADADR                                     "acc_carcm_cdr_darcm_cddddr"
CADAR                                      "acc_carcm_cdr_darcm_cddddr"
CADDAR                                     "acc_carcm_cdr_darcm_cddddr"
CADDDR                                     "acc_carcm_cdr_darcm_cddddr"
CADDR                                      "acc_carcm_cdr_darcm_cddddr"
CADR                                       "acc_carcm_cdr_darcm_cddddr"
CALL-ARGUMENTS-LIMIT                       "convar_call-a_uments-limit"
CALL-METHOD                                "locmac_call-m__make-method"
CALL-NEXT-METHOD                           "locfun_call-next-method"
CAR                                        "acc_carcm_cdr_darcm_cddddr"
CASE                                       "mac_casecm_ccasecm_ecase"
CATCH                                      "speope_catch"
CCASE                                      "mac_casecm_ccasecm_ecase"
CDAAAR                                     "acc_carcm_cdr_darcm_cddddr"
CDAADR                                     "acc_carcm_cdr_darcm_cddddr"
CDAAR                                      "acc_carcm_cdr_darcm_cddddr"
CDADAR                                     "acc_carcm_cdr_darcm_cddddr"
CDADDR                                     "acc_carcm_cdr_darcm_cddddr"
CDADR                                      "acc_carcm_cdr_darcm_cddddr"
CDAR                                       "acc_carcm_cdr_darcm_cddddr"
CDDAAR                                     "acc_carcm_cdr_darcm_cddddr"
CDDADR                                     "acc_carcm_cdr_darcm_cddddr"
CDDAR                                      "acc_carcm_cdr_darcm_cddddr"
CDDDAR                                     "acc_carcm_cdr_darcm_cddddr"
CDDDDR                                     "acc_carcm_cdr_darcm_cddddr"
CDDDR                                      "acc_carcm_cdr_darcm_cddddr"
CDDR                                       "acc_carcm_cdr_darcm_cddddr"
CDR                                        "acc_carcm_cdr_darcm_cddddr"
CEILING                                    "fun_floorcm_f_undcm_fround"
CELL-ERROR                                 "contyp_cell-error"
CELL-ERROR-NAME                            "fun_cell-error-name"
CERROR                                     "fun_cerror"
CHANGE-CLASS                               "stagenfun_change-class"
CHAR                                       "acc_charcm_schar"
CHAR-CODE                                  "fun_char-code"
CHAR-CODE-LIMIT                            "convar_char-code-limit"
CHAR-DOWNCASE                              "fun_char-upca_har-downcase"
CHAR-EQUAL                                 "fun_chareqcm__ar-not-lessp"
CHAR-GREATERP                              "fun_chareqcm__ar-not-lessp"
CHAR-INT                                   "fun_char-int"
CHAR-LESSP                                 "fun_chareqcm__ar-not-lessp"
CHAR-NAME                                  "fun_char-name"
CHAR-NOT-EQUAL                             "fun_chareqcm__ar-not-lessp"
CHAR-NOT-GREATERP                          "fun_chareqcm__ar-not-lessp"
CHAR-NOT-LESSP                             "fun_chareqcm__ar-not-lessp"
CHAR-UPCASE                                "fun_char-upca_har-downcase"
CHAR/=                                     "fun_chareqcm__ar-not-lessp"
CHAR&LT;                                   "fun_chareqcm__ar-not-lessp"
CHAR&LT;=                                  "fun_chareqcm__ar-not-lessp"
CHAR=                                      "fun_chareqcm__ar-not-lessp"
CHAR&GT;                                   "fun_chareqcm__ar-not-lessp"
CHAR&GT;=                                  "fun_chareqcm__ar-not-lessp"
CHARACTER                                  "any_character"
CHARACTERP                                 "fun_characterp"
CHECK-TYPE                                 "mac_check-type"
CIS                                        "fun_cis"
CLASS                                      "syscla_class"
CLASS-NAME                                 "stagenfun_class-name"
CLASS-OF                                   "fun_class-of"
CLEAR-INPUT                                "fun_clear-input"
CLEAR-OUTPUT                               "fun_finish-ou_clear-output"
CLOSE                                      "fun_close"
CLRHASH                                    "fun_clrhash"
CODE-CHAR                                  "fun_code-char"
COERCE                                     "fun_coerce"
COMPILATION-SPEED                          "dec_optimize"
COMPILE                                    "fun_compile"
COMPILE-FILE                               "fun_compile-file"
COMPILE-FILE-PATHNAME                      "fun_compile-file-pathname"
COMPILED-FUNCTION                          "typ_compiled-function"
COMPILED-FUNCTION-P                        "fun_compiled-function-p"
COMPILER-MACRO                             "stagenfun_doc_umentationcp"
COMPILER-MACRO-FUNCTION                    "acc_compiler-_cro-function"
COMPLEMENT                                 "fun_complement"
COMPLEX                                    "any_complex"
COMPLEXP                                   "fun_complexp"
COMPUTE-APPLICABLE-METHODS                 "stagenfun_com_able-methods"
COMPUTE-RESTARTS                           "fun_compute-restarts"
CONCATENATE                                "fun_concatenate"
CONCATENATED-STREAM                        "syscla_concatenated-stream"
CONCATENATED-STREAM-STREAMS                "fun_concatena_ream-streams"
COND                                       "mac_cond"
CONDITION                                  "contyp_condition"
CONJUGATE                                  "fun_conjugate"
CONS                                       "any_cons"
CONSP                                      "fun_consp"
CONSTANTLY                                 "fun_constantly"
CONSTANTP                                  "fun_constantp"
CONTINUE                                   "any_continue"
CONTROL-ERROR                              "contyp_control-error"
COPY-ALIST                                 "fun_copy-alist"
COPY-LIST                                  "fun_copy-list"
COPY-PPRINT-DISPATCH                       "fun_copy-pprint-dispatch"
COPY-READTABLE                             "fun_copy-readtable"
COPY-SEQ                                   "fun_copy-seq"
COPY-STRUCTURE                             "fun_copy-structure"
COPY-SYMBOL                                "fun_copy-symbol"
COPY-TREE                                  "fun_copy-tree"
COS                                        "fun_sincm_coscm_tan"
COSH                                       "fun_sinhcm_co_coshcm_atanh"
COUNT                                      "fun_countcm_c_count-if-not"
COUNT-IF                                   "fun_countcm_c_count-if-not"
COUNT-IF-NOT                               "fun_countcm_c_count-if-not"
CTYPECASE                                  "mac_typecasec_cm_etypecase"
DEBUG                                      "dec_optimize"
DECF                                       "mac_incfcm_decf"
DECLAIM                                    "mac_declaim"
DECLARATION                                "dec_declaration"
DECLARE                                    "sym_declare"
DECODE-FLOAT                               "fun_decode-fl_decode-float"
DECODE-UNIVERSAL-TIME                      "fun_decode-universal-time"
DEFCLASS                                   "mac_defclass"
DEFCONSTANT                                "mac_defconstant"
DEFGENERIC                                 "mac_defgeneric"
DEFINE-COMPILER-MACRO                      "mac_define-compiler-macro"
DEFINE-CONDITION                           "mac_define-condition"
DEFINE-METHOD-COMBINATION                  "mac_define-me_-combination"
DEFINE-MODIFY-MACRO                        "mac_define-modify-macro"
DEFINE-SETF-EXPANDER                       "mac_define-setf-expander"
DEFINE-SYMBOL-MACRO                        "mac_define-symbol-macro"
DEFMACRO                                   "mac_defmacro"
DEFMETHOD                                  "mac_defmethod"
DEFPACKAGE                                 "mac_defpackage"
DEFPARAMETER                               "mac_defparametercm_defvar"
DEFSETF                                    "mac_defsetf"
DEFSTRUCT                                  "mac_defstruct"
DEFTYPE                                    "mac_deftype"
DEFUN                                      "mac_defun"
DEFVAR                                     "mac_defparametercm_defvar"
DELETE                                     "fun_removecm__elete-if-not"
DELETE-DUPLICATES                          "fun_remove-du_e-duplicates"
DELETE-FILE                                "fun_delete-file"
DELETE-IF                                  "fun_removecm__elete-if-not"
DELETE-IF-NOT                              "fun_removecm__elete-if-not"
DELETE-PACKAGE                             "fun_delete-package"
DENOMINATOR                                "fun_numerator__denominator"
DEPOSIT-FIELD                              "fun_deposit-field"
DESCRIBE                                   "fun_describe"
DESCRIBE-OBJECT                            "stagenfun_describe-object"
DESTRUCTURING-BIND                         "mac_destructuring-bind"
DIGIT-CHAR                                 "fun_digit-char"
DIGIT-CHAR-P                               "fun_digit-char-p"
DIRECTORY                                  "fun_directory"
DIRECTORY-NAMESTRING                       "fun_namestrin_h-namestring"
DISASSEMBLE                                "fun_disassemble"
DIVISION-BY-ZERO                           "contyp_division-by-zero"
DO                                         "mac_docm_dost"
DO*                                        "mac_docm_dost"
DO-ALL-SYMBOLS                             "mac_do-symbol_-all-symbols"
DO-EXTERNAL-SYMBOLS                        "mac_do-symbol_-all-symbols"
DO-SYMBOLS                                 "mac_do-symbol_-all-symbols"
DOCUMENTATION                              "stagenfun_doc_umentationcp"
DOLIST                                     "mac_dolist"
DOTIMES                                    "mac_dotimes"
DOUBLE-FLOAT                               "typ_short-flo_m_long-float"
DOUBLE-FLOAT-EPSILON                       "convar_short-_tive-epsilon"
DOUBLE-FLOAT-NEGATIVE-EPSILON              "convar_short-_tive-epsilon"
DPB                                        "fun_dpb"
DRIBBLE                                    "fun_dribble"
DYNAMIC-EXTENT                             "dec_dynamic-extent"
ECASE                                      "mac_casecm_ccasecm_ecase"
ECHO-STREAM                                "syscla_echo-stream"
ECHO-STREAM-INPUT-STREAM                   "fun_echo-stre_utput-stream"
ECHO-STREAM-OUTPUT-STREAM                  "fun_echo-stre_utput-stream"
ED                                         "fun_ed"
EIGHTH                                     "acc_firstcm_s_inthcm_tenth"
ELT                                        "acc_elt"
ENCODE-UNIVERSAL-TIME                      "fun_encode-universal-time"
END-OF-FILE                                "contyp_end-of-file"
ENDP                                       "fun_endp"
ENOUGH-NAMESTRING                          "fun_namestrin_h-namestring"
ENSURE-DIRECTORIES-EXIST                   "fun_ensure-di_tories-exist"
ENSURE-GENERIC-FUNCTION                    "fun_ensure-ge_ric-function"
EQ                                         "fun_eq"
EQL                                        "any_eql"
EQUAL                                      "fun_equal"
EQUALP                                     "fun_equalp"
ERROR                                      "any_error"
ETYPECASE                                  "mac_typecasec_cm_etypecase"
EVAL                                       "fun_eval"
EVAL-WHEN                                  "speope_eval-when"
EVENP                                      "fun_evenpcm_oddp"
EVERY                                      "fun_everycm_s_erycm_notany"
EXP                                        "fun_expcm_expt"
EXPORT                                     "fun_export"
EXPT                                       "fun_expcm_expt"
EXTENDED-CHAR                              "typ_extended-char"
FBOUNDP                                    "fun_fboundp"
FCEILING                                   "fun_floorcm_f_undcm_fround"
FDEFINITION                                "acc_fdefinition"
FFLOOR                                     "fun_floorcm_f_undcm_fround"
FIFTH                                      "acc_firstcm_s_inthcm_tenth"
FILE-AUTHOR                                "fun_file-author"
FILE-ERROR                                 "contyp_file-error"
FILE-ERROR-PATHNAME                        "fun_file-error-pathname"
FILE-LENGTH                                "fun_file-length"
FILE-NAMESTRING                            "fun_namestrin_h-namestring"
FILE-POSITION                              "fun_file-position"
FILE-STREAM                                "syscla_file-stream"
FILE-STRING-LENGTH                         "fun_file-string-length"
FILE-WRITE-DATE                            "fun_file-write-date"
FILL                                       "fun_fill"
FILL-POINTER                               "acc_fill-pointer"
FIND                                       "fun_findcm_fi__find-if-not"
FIND-ALL-SYMBOLS                           "fun_find-all-symbols"
FIND-CLASS                                 "acc_find-class"
FIND-IF                                    "fun_findcm_fi__find-if-not"
FIND-IF-NOT                                "fun_findcm_fi__find-if-not"
FIND-METHOD                                "stagenfun_find-method"
FIND-PACKAGE                               "fun_find-package"
FIND-RESTART                               "fun_find-restart"
FIND-SYMBOL                                "fun_find-symbol"
FINISH-OUTPUT                              "fun_finish-ou_clear-output"
FIRST                                      "acc_firstcm_s_inthcm_tenth"
FIXNUM                                     "typ_fixnum"
FLET                                       "speope_fletcm_scm_macrolet"
FLOAT                                      "any_float"
FLOAT-DIGITS                               "fun_decode-fl_decode-float"
FLOAT-PRECISION                            "fun_decode-fl_decode-float"
FLOAT-RADIX                                "fun_decode-fl_decode-float"
FLOAT-SIGN                                 "fun_decode-fl_decode-float"
FLOATING-POINT-INEXACT                     "contyp_floati_oint-inexact"
FLOATING-POINT-INVALID-OPERATION           "contyp_floati_id-operation"
FLOATING-POINT-OVERFLOW                    "contyp_floati_int-overflow"
FLOATING-POINT-UNDERFLOW                   "contyp_floati_nt-underflow"
FLOATP                                     "fun_floatp"
FLOOR                                      "fun_floorcm_f_undcm_fround"
FMAKUNBOUND                                "fun_fmakunbound"
FORCE-OUTPUT                               "fun_finish-ou_clear-output"
FORMAT                                     "fun_format"
FORMATTER                                  "mac_formatter"
FOURTH                                     "acc_firstcm_s_inthcm_tenth"
FRESH-LINE                                 "fun_terpricm_fresh-line"
FROUND                                     "fun_floorcm_f_undcm_fround"
FTRUNCATE                                  "fun_floorcm_f_undcm_fround"
FTYPE                                      "dec_ftype"
FUNCALL                                    "fun_funcall"
FUNCTION                                   "any_function"
FUNCTION-KEYWORDS                          "stagenfun_fun_ion-keywords"
FUNCTION-LAMBDA-EXPRESSION                 "fun_function-_a-expression"
FUNCTIONP                                  "fun_functionp"
GCD                                        "fun_gcd"
GENERIC-FUNCTION                           "syscla_generic-function"
GENSYM                                     "fun_gensym"
GENTEMP                                    "fun_gentemp"
GET                                        "acc_get"
GET-DECODED-TIME                           "fun_get-unive_decoded-time"
GET-DISPATCH-MACRO-CHARACTER               "fun_set-dispa_ro-character"
GET-INTERNAL-REAL-TIME                     "fun_get-internal-real-time"
GET-INTERNAL-RUN-TIME                      "fun_get-internal-run-time"
GET-MACRO-CHARACTER                        "fun_set-macro_ro-character"
GET-OUTPUT-STREAM-STRING                   "fun_get-outpu_tream-string"
GET-PROPERTIES                             "fun_get-properties"
GET-SETF-EXPANSION                         "fun_get-setf-expansion"
GET-UNIVERSAL-TIME                         "fun_get-unive_decoded-time"
GETF                                       "acc_getf"
GETHASH                                    "acc_gethash"
GO                                         "speope_go"
GRAPHIC-CHAR-P                             "fun_graphic-char-p"
HANDLER-BIND                               "mac_handler-bind"
HANDLER-CASE                               "mac_handler-case"
HASH-TABLE                                 "syscla_hash-table"
HASH-TABLE-COUNT                           "fun_hash-table-count"
HASH-TABLE-P                               "fun_hash-table-p"
HASH-TABLE-REHASH-SIZE                     "fun_hash-table-rehash-size"
HASH-TABLE-REHASH-THRESHOLD                "fun_hash-tabl_sh-threshold"
HASH-TABLE-SIZE                            "fun_hash-table-size"
HASH-TABLE-TEST                            "fun_hash-table-test"
HOST-NAMESTRING                            "fun_namestrin_h-namestring"
IDENTITY                                   "fun_identity"
IF                                         "speope_if"
IGNORABLE                                  "dec_ignorecm_ignorable"
IGNORE                                     "dec_ignorecm_ignorable"
IGNORE-ERRORS                              "mac_ignore-errors"
IMAGPART                                   "fun_realpartcm_imagpart"
IMPORT                                     "fun_import"
IN-PACKAGE                                 "mac_in-package"
INCF                                       "mac_incfcm_decf"
INITIALIZE-INSTANCE                        "stagenfun_ini_ize-instance"
INLINE                                     "dec_inlinecm_notinline"
INPUT-STREAM-P                             "fun_input-str_put-stream-p"
INSPECT                                    "fun_inspect"
INTEGER                                    "syscla_integer"
INTEGER-DECODE-FLOAT                       "fun_decode-fl_decode-float"
INTEGER-LENGTH                             "fun_integer-length"
INTEGERP                                   "fun_integerp"
INTERACTIVE-STREAM-P                       "fun_interactive-stream-p"
INTERN                                     "fun_intern"
INTERNAL-TIME-UNITS-PER-SECOND             "convar_intern_s-per-second"
INTERSECTION                               "fun_intersect_intersection"
INVALID-METHOD-ERROR                       "fun_invalid-method-error"
INVOKE-DEBUGGER                            "fun_invoke-debugger"
INVOKE-RESTART                             "fun_invoke-restart"
INVOKE-RESTART-INTERACTIVELY               "fun_invoke-re_nteractively"
ISQRT                                      "fun_sqrtcm_isqrt"
KEYWORD                                    "typ_keyword"
KEYWORDP                                   "fun_keywordp"
LABELS                                     "speope_fletcm_scm_macrolet"
LAMBDA                                     "any_lambda"
LAMBDA-LIST-KEYWORDS                       "convar_lambda_ist-keywords"
LAMBDA-PARAMETERS-LIMIT                    "convar_lambda_meters-limit"
LAST                                       "fun_last"
LCM                                        "fun_lcm"
LDB                                        "acc_ldb"
LDB-TEST                                   "fun_ldb-test"
LDIFF                                      "fun_ldiffcm_tailp"
LEAST-NEGATIVE-DOUBLE-FLOAT                "convar_most-p_d-long-float"
LEAST-NEGATIVE-LONG-FLOAT                  "convar_most-p_d-long-float"
LEAST-NEGATIVE-NORMALIZED-DOUBLE-FLOAT     "convar_most-p_d-long-float"
LEAST-NEGATIVE-NORMALIZED-LONG-FLOAT       "convar_most-p_d-long-float"
LEAST-NEGATIVE-NORMALIZED-SHORT-FLOAT      "convar_most-p_d-long-float"
LEAST-NEGATIVE-NORMALIZED-SINGLE-FLOAT     "convar_most-p_d-long-float"
LEAST-NEGATIVE-SHORT-FLOAT                 "convar_most-p_d-long-float"
LEAST-NEGATIVE-SINGLE-FLOAT                "convar_most-p_d-long-float"
LEAST-POSITIVE-DOUBLE-FLOAT                "convar_most-p_d-long-float"
LEAST-POSITIVE-LONG-FLOAT                  "convar_most-p_d-long-float"
LEAST-POSITIVE-NORMALIZED-DOUBLE-FLOAT     "convar_most-p_d-long-float"
LEAST-POSITIVE-NORMALIZED-LONG-FLOAT       "convar_most-p_d-long-float"
LEAST-POSITIVE-NORMALIZED-SHORT-FLOAT      "convar_most-p_d-long-float"
LEAST-POSITIVE-NORMALIZED-SINGLE-FLOAT     "convar_most-p_d-long-float"
LEAST-POSITIVE-SHORT-FLOAT                 "convar_most-p_d-long-float"
LEAST-POSITIVE-SINGLE-FLOAT                "convar_most-p_d-long-float"
LENGTH                                     "fun_length"
LET                                        "speope_letcm_letst"
LET*                                       "speope_letcm_letst"
LISP-IMPLEMENTATION-TYPE                   "fun_lisp-impl_tion-version"
LISP-IMPLEMENTATION-VERSION                "fun_lisp-impl_tion-version"
LIST                                       "any_list"
LIST*                                      "fun_listcm_listst"
LIST-ALL-PACKAGES                          "fun_list-all-packages"
LIST-LENGTH                                "fun_list-length"
LISTEN                                     "fun_listen"
LISTP                                      "fun_listp"
LOAD                                       "fun_load"
LOAD-LOGICAL-PATHNAME-TRANSLATIONS         "fun_load-logi_translations"
LOAD-TIME-VALUE                            "speope_load-time-value"
LOCALLY                                    "speope_locally"
LOG                                        "fun_log"
LOGAND                                     "fun_logandcm__rc2cm_logxor"
LOGANDC1                                   "fun_logandcm__rc2cm_logxor"
LOGANDC2                                   "fun_logandcm__rc2cm_logxor"
LOGBITP                                    "fun_logbitp"
LOGCOUNT                                   "fun_logcount"
LOGEQV                                     "fun_logandcm__rc2cm_logxor"
LOGICAL-PATHNAME                           "any_logical-pathname"
LOGICAL-PATHNAME-TRANSLATIONS              "acc_logical-p_translations"
LOGIOR                                     "fun_logandcm__rc2cm_logxor"
LOGNAND                                    "fun_logandcm__rc2cm_logxor"
LOGNOR                                     "fun_logandcm__rc2cm_logxor"
LOGNOT                                     "fun_logandcm__rc2cm_logxor"
LOGORC1                                    "fun_logandcm__rc2cm_logxor"
LOGORC2                                    "fun_logandcm__rc2cm_logxor"
LOGTEST                                    "fun_logtest"
LOGXOR                                     "fun_logandcm__rc2cm_logxor"
LONG-FLOAT                                 "typ_short-flo_m_long-float"
LONG-FLOAT-EPSILON                         "convar_short-_tive-epsilon"
LONG-FLOAT-NEGATIVE-EPSILON                "convar_short-_tive-epsilon"
LONG-SITE-NAME                             "fun_short-sit_ng-site-name"
LOOP                                       "mac_loop"
LOOP-FINISH                                "locmac_loop-finish"
LOWER-CASE-P                               "fun_upper-cas__both-case-p"
MACHINE-INSTANCE                           "fun_machine-instance"
MACHINE-TYPE                               "fun_machine-type"
MACHINE-VERSION                            "fun_machine-version"
MACRO-FUNCTION                             "acc_macro-function"
MACROEXPAND                                "fun_macroexpa_acroexpand-1"
MACROEXPAND-1                              "fun_macroexpa_acroexpand-1"
MACROLET                                   "speope_fletcm_scm_macrolet"
MAKE-ARRAY                                 "fun_make-array"
MAKE-BROADCAST-STREAM                      "fun_make-broadcast-stream"
MAKE-CONCATENATED-STREAM                   "fun_make-conc_nated-stream"
MAKE-CONDITION                             "fun_make-condition"
MAKE-DISPATCH-MACRO-CHARACTER              "fun_make-disp_ro-character"
MAKE-ECHO-STREAM                           "fun_make-echo-stream"
MAKE-HASH-TABLE                            "fun_make-hash-table"
MAKE-INSTANCE                              "stagenfun_make-instance"
MAKE-INSTANCES-OBSOLETE                    "stagenfun_mak_ces-obsolete"
MAKE-LIST                                  "fun_make-list"
MAKE-LOAD-FORM                             "stagenfun_make-load-form"
MAKE-LOAD-FORM-SAVING-SLOTS                "fun_make-load_saving-slots"
MAKE-METHOD                                "locmac_call-m__make-method"
MAKE-PACKAGE                               "fun_make-package"
MAKE-PATHNAME                              "fun_make-pathname"
MAKE-RANDOM-STATE                          "fun_make-random-state"
MAKE-SEQUENCE                              "fun_make-sequence"
MAKE-STRING                                "fun_make-string"
MAKE-STRING-INPUT-STREAM                   "fun_make-stri_input-stream"
MAKE-STRING-OUTPUT-STREAM                  "fun_make-stri_utput-stream"
MAKE-SYMBOL                                "fun_make-symbol"
MAKE-SYNONYM-STREAM                        "fun_make-synonym-stream"
MAKE-TWO-WAY-STREAM                        "fun_make-two-way-stream"
MAKUNBOUND                                 "fun_makunbound"
MAP                                        "fun_map"
MAP-INTO                                   "fun_map-into"
MAPC                                       "fun_mapccm_ma_istcm_mapcon"
MAPCAN                                     "fun_mapccm_ma_istcm_mapcon"
MAPCAR                                     "fun_mapccm_ma_istcm_mapcon"
MAPCON                                     "fun_mapccm_ma_istcm_mapcon"
MAPHASH                                    "fun_maphash"
MAPL                                       "fun_mapccm_ma_istcm_mapcon"
MAPLIST                                    "fun_mapccm_ma_istcm_mapcon"
MASK-FIELD                                 "acc_mask-field"
MAX                                        "fun_maxcm_min"
MEMBER                                     "any_member"
MEMBER-IF                                  "fun_membercm__ember-if-not"
MEMBER-IF-NOT                              "fun_membercm__ember-if-not"
MERGE                                      "fun_merge"
MERGE-PATHNAMES                            "fun_merge-pathnames"
METHOD                                     "syscla_method"
METHOD-COMBINATION                         "any_method-combination"
METHOD-COMBINATION-ERROR                   "fun_method-co_nation-error"
METHOD-QUALIFIERS                          "stagenfun_met_d-qualifiers"
MIN                                        "fun_maxcm_min"
MINUSP                                     "fun_minuspcm_plusp"
MISMATCH                                   "fun_mismatch"
MOD                                        "any_mod"
MOST-NEGATIVE-DOUBLE-FLOAT                 "convar_most-p_d-long-float"
MOST-NEGATIVE-FIXNUM                       "convar_most-p_ative-fixnum"
MOST-NEGATIVE-LONG-FLOAT                   "convar_most-p_d-long-float"
MOST-NEGATIVE-SHORT-FLOAT                  "convar_most-p_d-long-float"
MOST-NEGATIVE-SINGLE-FLOAT                 "convar_most-p_d-long-float"
MOST-POSITIVE-DOUBLE-FLOAT                 "convar_most-p_d-long-float"
MOST-POSITIVE-FIXNUM                       "convar_most-p_ative-fixnum"
MOST-POSITIVE-LONG-FLOAT                   "convar_most-p_d-long-float"
MOST-POSITIVE-SHORT-FLOAT                  "convar_most-p_d-long-float"
MOST-POSITIVE-SINGLE-FLOAT                 "convar_most-p_d-long-float"
MUFFLE-WARNING                             "any_muffle-warning"
MULTIPLE-VALUE-BIND                        "mac_multiple-value-bind"
MULTIPLE-VALUE-CALL                        "speope_multiple-value-call"
MULTIPLE-VALUE-LIST                        "mac_multiple-value-list"
MULTIPLE-VALUE-PROG1                       "speope_multip_-value-prog1"
MULTIPLE-VALUE-SETQ                        "mac_multiple-value-setq"
MULTIPLE-VALUES-LIMIT                      "convar_multip_values-limit"
NAME-CHAR                                  "fun_name-char"
NAMESTRING                                 "fun_namestrin_h-namestring"
NBUTLAST                                   "fun_butlastcm_nbutlast"
NCONC                                      "fun_nconc"
NEXT-METHOD-P                              "locfun_next-method-p"
NIL                                        "any_nil"
NINTERSECTION                              "fun_intersect_intersection"
NINTH                                      "acc_firstcm_s_inthcm_tenth"
NO-APPLICABLE-METHOD                       "stagenfun_no-_cable-method"
NO-NEXT-METHOD                             "stagenfun_no-next-method"
NOT                                        "any_not"
NOTANY                                     "fun_everycm_s_erycm_notany"
NOTEVERY                                   "fun_everycm_s_erycm_notany"
NOTINLINE                                  "dec_inlinecm_notinline"
NRECONC                                    "fun_revappendcm_nreconc"
NREVERSE                                   "fun_reversecm_nreverse"
NSET-DIFFERENCE                            "fun_set-diffe_t-difference"
NSET-EXCLUSIVE-OR                          "fun_set-exclu_exclusive-or"
NSTRING-CAPITALIZE                         "fun_string-up_g-capitalize"
NSTRING-DOWNCASE                           "fun_string-up_g-capitalize"
NSTRING-UPCASE                             "fun_string-up_g-capitalize"
NSUBLIS                                    "fun_subliscm_nsublis"
NSUBST                                     "fun_substcm_s_subst-if-not"
NSUBST-IF                                  "fun_substcm_s_subst-if-not"
NSUBST-IF-NOT                              "fun_substcm_s_subst-if-not"
NSUBSTITUTE                                "fun_substitut_itute-if-not"
NSUBSTITUTE-IF                             "fun_substitut_itute-if-not"
NSUBSTITUTE-IF-NOT                         "fun_substitut_itute-if-not"
NTH                                        "acc_nth"
NTH-VALUE                                  "mac_nth-value"
NTHCDR                                     "fun_nthcdr"
NULL                                       "any_null"
NUMBER                                     "syscla_number"
NUMBERP                                    "fun_numberp"
NUMERATOR                                  "fun_numerator__denominator"
NUNION                                     "fun_unioncm_nunion"
ODDP                                       "fun_evenpcm_oddp"
OPEN                                       "fun_open"
OPEN-STREAM-P                              "fun_open-stream-p"
OPTIMIZE                                   "dec_optimize"
OR                                         "any_or"
OTHERWISE                                  "mac_casecm_ccasecm_ecase"
OUTPUT-STREAM-P                            "fun_input-str_put-stream-p"
PACKAGE                                    "syscla_package"
PACKAGE-ERROR                              "contyp_package-error"
PACKAGE-ERROR-PACKAGE                      "fun_package-error-package"
PACKAGE-NAME                               "fun_package-name"
PACKAGE-NICKNAMES                          "fun_package-nicknames"
PACKAGE-SHADOWING-SYMBOLS                  "fun_package-s_wing-symbols"
PACKAGE-USE-LIST                           "fun_package-use-list"
PACKAGE-USED-BY-LIST                       "fun_package-used-by-list"
PACKAGEP                                   "fun_packagep"
PAIRLIS                                    "fun_pairlis"
PARSE-ERROR                                "contyp_parse-error"
PARSE-INTEGER                              "fun_parse-integer"
PARSE-NAMESTRING                           "fun_parse-namestring"
PATHNAME                                   "any_pathname"
PATHNAME-DEVICE                            "fun_pathname-_name-version"
PATHNAME-DIRECTORY                         "fun_pathname-_name-version"
PATHNAME-HOST                              "fun_pathname-_name-version"
PATHNAME-MATCH-P                           "fun_pathname-match-p"
PATHNAME-NAME                              "fun_pathname-_name-version"
PATHNAME-TYPE                              "fun_pathname-_name-version"
PATHNAME-VERSION                           "fun_pathname-_name-version"
PATHNAMEP                                  "fun_pathnamep"
PEEK-CHAR                                  "fun_peek-char"
PHASE                                      "fun_phase"
PI                                         "convar_pi"
PLUSP                                      "fun_minuspcm_plusp"
POP                                        "mac_pop"
POSITION                                   "fun_positionc_ition-if-not"
POSITION-IF                                "fun_positionc_ition-if-not"
POSITION-IF-NOT                            "fun_positionc_ition-if-not"
PPRINT                                     "fun_writecm_p_rintcm_princ"
PPRINT-DISPATCH                            "fun_pprint-dispatch"
PPRINT-EXIT-IF-LIST-EXHAUSTED              "locmac_pprint_st-exhausted"
PPRINT-FILL                                "fun_pprint-fi_rint-tabular"
PPRINT-INDENT                              "fun_pprint-indent"
PPRINT-LINEAR                              "fun_pprint-fi_rint-tabular"
PPRINT-LOGICAL-BLOCK                       "mac_pprint-logical-block"
PPRINT-NEWLINE                             "fun_pprint-newline"
PPRINT-POP                                 "locmac_pprint-pop"
PPRINT-TAB                                 "fun_pprint-tab"
PPRINT-TABULAR                             "fun_pprint-fi_rint-tabular"
PRIN1                                      "fun_writecm_p_rintcm_princ"
PRIN1-TO-STRING                            "fun_write-to-_nc-to-string"
PRINC                                      "fun_writecm_p_rintcm_princ"
PRINC-TO-STRING                            "fun_write-to-_nc-to-string"
PRINT                                      "fun_writecm_p_rintcm_princ"
PRINT-NOT-READABLE                         "contyp_print-not-readable"
PRINT-NOT-READABLE-OBJECT                  "fun_print-not_dable-object"
PRINT-OBJECT                               "stagenfun_print-object"
PRINT-UNREADABLE-OBJECT                    "mac_print-unr_dable-object"
PROBE-FILE                                 "fun_probe-file"
PROCLAIM                                   "fun_proclaim"
PROG                                       "mac_progcm_progst"
PROG*                                      "mac_progcm_progst"
PROG1                                      "mac_prog1cm_prog2"
PROG2                                      "mac_prog1cm_prog2"
PROGN                                      "speope_progn"
PROGRAM-ERROR                              "contyp_program-error"
PROGV                                      "speope_progv"
PROVIDE                                    "fun_providecm_require"
PSETF                                      "mac_setfcm_psetf"
PSETQ                                      "mac_psetq"
PUSH                                       "mac_push"
PUSHNEW                                    "mac_pushnew"
QUOTE                                      "speope_quote"
RANDOM                                     "fun_random"
RANDOM-STATE                               "syscla_random-state"
RANDOM-STATE-P                             "fun_random-state-p"
RASSOC                                     "fun_rassoccm__assoc-if-not"
RASSOC-IF                                  "fun_rassoccm__assoc-if-not"
RASSOC-IF-NOT                              "fun_rassoccm__assoc-if-not"
RATIO                                      "syscla_ratio"
RATIONAL                                   "any_rational"
RATIONALIZE                                "fun_rationalcm_rationalize"
RATIONALP                                  "fun_rationalp"
READ                                       "fun_readcm_re_g-whitespace"
READ-BYTE                                  "fun_read-byte"
READ-CHAR                                  "fun_read-char"
READ-CHAR-NO-HANG                          "fun_read-char-no-hang"
READ-DELIMITED-LIST                        "fun_read-delimited-list"
READ-FROM-STRING                           "fun_read-from-string"
READ-LINE                                  "fun_read-line"
READ-PRESERVING-WHITESPACE                 "fun_readcm_re_g-whitespace"
READ-SEQUENCE                              "fun_read-sequence"
READER-ERROR                               "contyp_reader-error"
READTABLE                                  "syscla_readtable"
READTABLE-CASE                             "acc_readtable-case"
READTABLEP                                 "fun_readtablep"
REAL                                       "syscla_real"
REALP                                      "fun_realp"
REALPART                                   "fun_realpartcm_imagpart"
REDUCE                                     "fun_reduce"
REINITIALIZE-INSTANCE                      "stagenfun_rei_ize-instance"
REM                                        "fun_modcm_rem"
REMF                                       "mac_remf"
REMHASH                                    "fun_remhash"
REMOVE                                     "fun_removecm__elete-if-not"
REMOVE-DUPLICATES                          "fun_remove-du_e-duplicates"
REMOVE-IF                                  "fun_removecm__elete-if-not"
REMOVE-IF-NOT                              "fun_removecm__elete-if-not"
REMOVE-METHOD                              "stagenfun_remove-method"
REMPROP                                    "fun_remprop"
RENAME-FILE                                "fun_rename-file"
RENAME-PACKAGE                             "fun_rename-package"
REPLACE                                    "fun_replace"
REQUIRE                                    "fun_providecm_require"
REST                                       "acc_rest"
RESTART                                    "syscla_restart"
RESTART-BIND                               "mac_restart-bind"
RESTART-CASE                               "mac_restart-case"
RESTART-NAME                               "fun_restart-name"
RETURN                                     "mac_return"
RETURN-FROM                                "speope_return-from"
REVAPPEND                                  "fun_revappendcm_nreconc"
REVERSE                                    "fun_reversecm_nreverse"
ROOM                                       "fun_room"
ROTATEF                                    "mac_rotatef"
ROUND                                      "fun_floorcm_f_undcm_fround"
ROW-MAJOR-AREF                             "acc_row-major-aref"
RPLACA                                     "fun_rplacacm_rplacd"
RPLACD                                     "fun_rplacacm_rplacd"
SAFETY                                     "dec_optimize"
SATISFIES                                  "typspe_satisfies"
SBIT                                       "acc_bitcm_sbit"
SCALE-FLOAT                                "fun_decode-fl_decode-float"
SCHAR                                      "acc_charcm_schar"
SEARCH                                     "fun_search"
SECOND                                     "acc_firstcm_s_inthcm_tenth"
SEQUENCE                                   "syscla_sequence"
SERIOUS-CONDITION                          "contyp_serious-condition"
SET                                        "fun_set"
SET-DIFFERENCE                             "fun_set-diffe_t-difference"
SET-DISPATCH-MACRO-CHARACTER               "fun_set-dispa_ro-character"
SET-EXCLUSIVE-OR                           "fun_set-exclu_exclusive-or"
SET-MACRO-CHARACTER                        "fun_set-macro_ro-character"
SET-PPRINT-DISPATCH                        "fun_set-pprint-dispatch"
SET-SYNTAX-FROM-CHAR                       "fun_set-syntax-from-char"
SETF                                       "any_setf"
SETQ                                       "spefor_setq"
SEVENTH                                    "acc_firstcm_s_inthcm_tenth"
SHADOW                                     "fun_shadow"
SHADOWING-IMPORT                           "fun_shadowing-import"
SHARED-INITIALIZE                          "stagenfun_sha_d-initialize"
SHIFTF                                     "mac_shiftf"
SHORT-FLOAT                                "typ_short-flo_m_long-float"
SHORT-FLOAT-EPSILON                        "convar_short-_tive-epsilon"
SHORT-FLOAT-NEGATIVE-EPSILON               "convar_short-_tive-epsilon"
SHORT-SITE-NAME                            "fun_short-sit_ng-site-name"
SIGNAL                                     "fun_signal"
SIGNED-BYTE                                "typ_signed-byte"
SIGNUM                                     "fun_signum"
SIMPLE-ARRAY                               "typ_simple-array"
SIMPLE-BASE-STRING                         "typ_simple-base-string"
SIMPLE-BIT-VECTOR                          "typ_simple-bit-vector"
SIMPLE-BIT-VECTOR-P                        "fun_simple-bit-vector-p"
SIMPLE-CONDITION                           "contyp_simple-condition"
SIMPLE-CONDITION-FORMAT-ARGUMENTS          "fun_simple-co_at-arguments"
SIMPLE-CONDITION-FORMAT-CONTROL            "fun_simple-co_at-arguments"
SIMPLE-ERROR                               "contyp_simple-error"
SIMPLE-STRING                              "typ_simple-string"
SIMPLE-STRING-P                            "fun_simple-string-p"
SIMPLE-TYPE-ERROR                          "contyp_simple-type-error"
SIMPLE-VECTOR                              "typ_simple-vector"
SIMPLE-VECTOR-P                            "fun_simple-vector-p"
SIMPLE-WARNING                             "contyp_simple-warning"
SIN                                        "fun_sincm_coscm_tan"
SINGLE-FLOAT                               "typ_short-flo_m_long-float"
SINGLE-FLOAT-EPSILON                       "convar_short-_tive-epsilon"
SINGLE-FLOAT-NEGATIVE-EPSILON              "convar_short-_tive-epsilon"
SINH                                       "fun_sinhcm_co_coshcm_atanh"
SIXTH                                      "acc_firstcm_s_inthcm_tenth"
SLEEP                                      "fun_sleep"
SLOT-BOUNDP                                "fun_slot-boundp"
SLOT-EXISTS-P                              "fun_slot-exists-p"
SLOT-MAKUNBOUND                            "fun_slot-makunbound"
SLOT-MISSING                               "stagenfun_slot-missing"
SLOT-UNBOUND                               "stagenfun_slot-unbound"
SLOT-VALUE                                 "fun_slot-value"
SOFTWARE-TYPE                              "fun_software-_ware-version"
SOFTWARE-VERSION                           "fun_software-_ware-version"
SOME                                       "fun_everycm_s_erycm_notany"
SORT                                       "fun_sortcm_stable-sort"
SPACE                                      "dec_optimize"
SPECIAL                                    "dec_special"
SPECIAL-OPERATOR-P                         "fun_special-operator-p"
SPEED                                      "dec_optimize"
SQRT                                       "fun_sqrtcm_isqrt"
STABLE-SORT                                "fun_sortcm_stable-sort"
STANDARD                                   "sec_7-6-6-2"
STANDARD-CHAR                              "typ_standard-char"
STANDARD-CHAR-P                            "fun_standard-char-p"
STANDARD-CLASS                             "syscla_standard-class"
STANDARD-GENERIC-FUNCTION                  "syscla_standa_ric-function"
STANDARD-METHOD                            "syscla_standard-method"
STANDARD-OBJECT                            "cla_standard-object"
STEP                                       "mac_step"
STORAGE-CONDITION                          "contyp_storage-condition"
STORE-VALUE                                "any_store-value"
STREAM                                     "syscla_stream"
STREAM-ELEMENT-TYPE                        "fun_stream-element-type"
STREAM-ERROR                               "contyp_stream-error"
STREAM-ERROR-STREAM                        "fun_stream-error-stream"
STREAM-EXTERNAL-FORMAT                     "fun_stream-external-format"
STREAMP                                    "fun_streamp"
STRING                                     "any_string"
STRING-CAPITALIZE                          "fun_string-up_g-capitalize"
STRING-DOWNCASE                            "fun_string-up_g-capitalize"
STRING-EQUAL                               "fun_stringeqc_ng-not-lessp"
STRING-GREATERP                            "fun_stringeqc_ng-not-lessp"
STRING-LEFT-TRIM                           "fun_string-tr_g-right-trim"
STRING-LESSP                               "fun_stringeqc_ng-not-lessp"
STRING-NOT-EQUAL                           "fun_stringeqc_ng-not-lessp"
STRING-NOT-GREATERP                        "fun_stringeqc_ng-not-lessp"
STRING-NOT-LESSP                           "fun_stringeqc_ng-not-lessp"
STRING-RIGHT-TRIM                          "fun_string-tr_g-right-trim"
STRING-STREAM                              "syscla_string-stream"
STRING-TRIM                                "fun_string-tr_g-right-trim"
STRING-UPCASE                              "fun_string-up_g-capitalize"
STRING/=                                   "fun_stringeqc_ng-not-lessp"
STRING&LT;                                 "fun_stringeqc_ng-not-lessp"
STRING&LT;=                                "fun_stringeqc_ng-not-lessp"
STRING=                                    "fun_stringeqc_ng-not-lessp"
STRING&GT;                                 "fun_stringeqc_ng-not-lessp"
STRING&GT;=                                "fun_stringeqc_ng-not-lessp"
STRINGP                                    "fun_stringp"
STRUCTURE                                  "stagenfun_doc_umentationcp"
STRUCTURE-CLASS                            "syscla_structure-class"
STRUCTURE-OBJECT                           "cla_structure-object"
STYLE-WARNING                              "contyp_style-warning"
SUBLIS                                     "fun_subliscm_nsublis"
SUBSEQ                                     "acc_subseq"
SUBSETP                                    "fun_subsetp"
SUBST                                      "fun_substcm_s_subst-if-not"
SUBST-IF                                   "fun_substcm_s_subst-if-not"
SUBST-IF-NOT                               "fun_substcm_s_subst-if-not"
SUBSTITUTE                                 "fun_substitut_itute-if-not"
SUBSTITUTE-IF                              "fun_substitut_itute-if-not"
SUBSTITUTE-IF-NOT                          "fun_substitut_itute-if-not"
SUBTYPEP                                   "fun_subtypep"
SVREF                                      "acc_svref"
SXHASH                                     "fun_sxhash"
SYMBOL                                     "syscla_symbol"
SYMBOL-FUNCTION                            "acc_symbol-function"
SYMBOL-MACROLET                            "speope_symbol-macrolet"
SYMBOL-NAME                                "fun_symbol-name"
SYMBOL-PACKAGE                             "fun_symbol-package"
SYMBOL-PLIST                               "acc_symbol-plist"
SYMBOL-VALUE                               "acc_symbol-value"
SYMBOLP                                    "fun_symbolp"
SYNONYM-STREAM                             "syscla_synonym-stream"
SYNONYM-STREAM-SYMBOL                      "fun_synonym-stream-symbol"
T                                          "any_t"
TAGBODY                                    "speope_tagbody"
TAILP                                      "fun_ldiffcm_tailp"
TAN                                        "fun_sincm_coscm_tan"
TANH                                       "fun_sinhcm_co_coshcm_atanh"
TENTH                                      "acc_firstcm_s_inthcm_tenth"
TERPRI                                     "fun_terpricm_fresh-line"
THE                                        "speope_the"
THIRD                                      "acc_firstcm_s_inthcm_tenth"
THROW                                      "speope_throw"
TIME                                       "mac_time"
TRACE                                      "mac_tracecm_untrace"
TRANSLATE-LOGICAL-PATHNAME                 "fun_translate_cal-pathname"
TRANSLATE-PATHNAME                         "fun_translate-pathname"
TREE-EQUAL                                 "fun_tree-equal"
TRUENAME                                   "fun_truename"
TRUNCATE                                   "fun_floorcm_f_undcm_fround"
TWO-WAY-STREAM                             "syscla_two-way-stream"
TWO-WAY-STREAM-INPUT-STREAM                "fun_two-way-s_utput-stream"
TWO-WAY-STREAM-OUTPUT-STREAM               "fun_two-way-s_utput-stream"
TYPE                                       "any_type"
TYPE-ERROR                                 "contyp_type-error"
TYPE-ERROR-DATUM                           "fun_type-erro_xpected-type"
TYPE-ERROR-EXPECTED-TYPE                   "fun_type-erro_xpected-type"
TYPE-OF                                    "fun_type-of"
TYPECASE                                   "mac_typecasec_cm_etypecase"
TYPEP                                      "fun_typep"
UNBOUND-SLOT                               "contyp_unbound-slot"
UNBOUND-SLOT-INSTANCE                      "fun_unbound-slot-instance"
UNBOUND-VARIABLE                           "contyp_unbound-variable"
UNDEFINED-FUNCTION                         "contyp_undefined-function"
UNEXPORT                                   "fun_unexport"
UNINTERN                                   "fun_unintern"
UNION                                      "fun_unioncm_nunion"
UNLESS                                     "mac_whencm_unless"
UNREAD-CHAR                                "fun_unread-char"
UNSIGNED-BYTE                              "typ_unsigned-byte"
UNTRACE                                    "mac_tracecm_untrace"
UNUSE-PACKAGE                              "fun_unuse-package"
UNWIND-PROTECT                             "speope_unwind-protect"
UPDATE-INSTANCE-FOR-DIFFERENT-CLASS        "stagenfun_upd_ferent-class"
UPDATE-INSTANCE-FOR-REDEFINED-CLASS        "stagenfun_upd_efined-class"
UPGRADED-ARRAY-ELEMENT-TYPE                "fun_upgraded-_element-type"
UPGRADED-COMPLEX-PART-TYPE                 "fun_upgraded-_ex-part-type"
UPPER-CASE-P                               "fun_upper-cas__both-case-p"
USE-PACKAGE                                "fun_use-package"
USE-VALUE                                  "any_use-value"
USER-HOMEDIR-PATHNAME                      "fun_user-homedir-pathname"
VALUES                                     "any_values"
VALUES-LIST                                "fun_values-list"
VARIABLE                                   "stagenfun_doc_umentationcp"
VECTOR                                     "any_vector"
VECTOR-POP                                 "fun_vector-pop"
VECTOR-PUSH                                "fun_vector-pu_-push-extend"
VECTOR-PUSH-EXTEND                         "fun_vector-pu_-push-extend"
VECTORP                                    "fun_vectorp"
WARN                                       "fun_warn"
WARNING                                    "contyp_warning"
WHEN                                       "mac_whencm_unless"
WILD-PATHNAME-P                            "fun_wild-pathname-p"
WITH-ACCESSORS                             "mac_with-accessors"
WITH-COMPILATION-UNIT                      "mac_with-compilation-unit"
WITH-CONDITION-RESTARTS                    "mac_with-cond_ion-restarts"
WITH-HASH-TABLE-ITERATOR                   "mac_with-hash_ble-iterator"
WITH-INPUT-FROM-STRING                     "mac_with-input-from-string"
WITH-OPEN-FILE                             "mac_with-open-file"
WITH-OPEN-STREAM                           "mac_with-open-stream"
WITH-OUTPUT-TO-STRING                      "mac_with-output-to-string"
WITH-PACKAGE-ITERATOR                      "mac_with-package-iterator"
WITH-SIMPLE-RESTART                        "mac_with-simple-restart"
WITH-SLOTS                                 "mac_with-slots"
WITH-STANDARD-IO-SYNTAX                    "mac_with-stan_rd-io-syntax"
WRITE                                      "fun_writecm_p_rintcm_princ"
WRITE-BYTE                                 "fun_write-byte"
WRITE-CHAR                                 "fun_write-char"
WRITE-LINE                                 "fun_write-str_m_write-line"
WRITE-SEQUENCE                             "fun_write-sequence"
WRITE-STRING                               "fun_write-str_m_write-line"
WRITE-TO-STRING                            "fun_write-to-_nc-to-string"
Y-OR-N-P                                   "fun_y-or-n-pcm_yes-or-no-p"
YES-OR-NO-P                                "fun_y-or-n-pcm_yes-or-no-p"
ZEROP                                      "fun_zerop"
	)
	;; else version 6
	#(
&AMP;ALLOW-OTHER-KEYS                      "03_da.htm#AMallow-other-keys"
&AMP;AUX                                   "03_da.htm#AMaux"
&AMP;BODY                                  "03_dd.htm#AMbody"
&AMP;ENVIRONMENT                           "03_dd.htm#AMenvironment"
&AMP;KEY                                   "03_da.htm#AMkey"
&AMP;OPTIONAL                              "03_da.htm#AMoptional"
&AMP;REST                                  "03_da.htm#AMrest"
&AMP;WHOLE                                 "03_dd.htm#AMwhole"
*                                          "a_st.htm#ST"
**                                         "v__stst_.htm#STST"
***                                        "v__stst_.htm#STSTST"
*BREAK-ON-SIGNALS*                         "v_break_.htm#STbreak-on-signalsST"
*COMPILE-FILE-PATHNAME*                    "v_cmp_fi.htm#STcompile-file-pathnameST"
*COMPILE-FILE-TRUENAME*                    "v_cmp_fi.htm#STcompile-file-truenameST"
*COMPILE-PRINT*                            "v_cmp_pr.htm#STcompile-printST"
*COMPILE-VERBOSE*                          "v_cmp_pr.htm#STcompile-verboseST"
*DEBUG-IO*                                 "v_debug_.htm#STdebug-ioST"
*DEBUGGER-HOOK*                            "v_debugg.htm#STdebugger-hookST"
*DEFAULT-PATHNAME-DEFAULTS*                "v_defaul.htm#STdefault-pathname-defaultsST"
*ERROR-OUTPUT*                             "v_debug_.htm#STerror-outputST"
*FEATURES*                                 "v_featur.htm#STfeaturesST"
*GENSYM-COUNTER*                           "v_gensym.htm#STgensym-counterST"
*LOAD-PATHNAME*                            "v_ld_pns.htm#STload-pathnameST"
*LOAD-PRINT*                               "v_ld_prs.htm#STload-printST"
*LOAD-TRUENAME*                            "v_ld_pns.htm#STload-truenameST"
*LOAD-VERBOSE*                             "v_ld_prs.htm#STload-verboseST"
*MACROEXPAND-HOOK*                         "v_mexp_h.htm#STmacroexpand-hookST"
*MODULES*                                  "v_module.htm#STmodulesST"
*PACKAGE*                                  "v_pkg.htm#STpackageST"
*PRINT-ARRAY*                              "v_pr_ar.htm#STprint-arrayST"
*PRINT-BASE*                               "v_pr_bas.htm#STprint-baseST"
*PRINT-CASE*                               "v_pr_cas.htm#STprint-caseST"
*PRINT-CIRCLE*                             "v_pr_cir.htm#STprint-circleST"
*PRINT-ESCAPE*                             "v_pr_esc.htm#STprint-escapeST"
*PRINT-GENSYM*                             "v_pr_gen.htm#STprint-gensymST"
*PRINT-LENGTH*                             "v_pr_lev.htm#STprint-lengthST"
*PRINT-LEVEL*                              "v_pr_lev.htm#STprint-levelST"
*PRINT-LINES*                              "v_pr_lin.htm#STprint-linesST"
*PRINT-MISER-WIDTH*                        "v_pr_mis.htm#STprint-miser-widthST"
*PRINT-PPRINT-DISPATCH*                    "v_pr_ppr.htm#STprint-pprint-dispatchST"
*PRINT-PRETTY*                             "v_pr_pre.htm#STprint-prettyST"
*PRINT-RADIX*                              "v_pr_bas.htm#STprint-radixST"
*PRINT-READABLY*                           "v_pr_rda.htm#STprint-readablyST"
*PRINT-RIGHT-MARGIN*                       "v_pr_rig.htm#STprint-right-marginST"
*QUERY-IO*                                 "v_debug_.htm#STquery-ioST"
*RANDOM-STATE*                             "v_rnd_st.htm#STrandom-stateST"
*READ-BASE*                                "v_rd_bas.htm#STread-baseST"
*READ-DEFAULT-FLOAT-FORMAT*                "v_rd_def.htm#STread-default-float-formatST"
*READ-EVAL*                                "v_rd_eva.htm#STread-evalST"
*READ-SUPPRESS*                            "v_rd_sup.htm#STread-suppressST"
*READTABLE*                                "v_rdtabl.htm#STreadtableST"
*STANDARD-INPUT*                           "v_debug_.htm#STstandard-inputST"
*STANDARD-OUTPUT*                          "v_debug_.htm#STstandard-outputST"
*TERMINAL-IO*                              "v_termin.htm#STterminal-ioST"
*TRACE-OUTPUT*                             "v_debug_.htm#STtrace-outputST"
+                                          "a_pl.htm#PL"
++                                         "v_pl_plp.htm#PLPL"
+++                                        "v_pl_plp.htm#PLPLPL"
-                                          "a__.htm#-"
/                                          "a_sl.htm#SL"
//                                         "v_sl_sls.htm#SLSL"
///                                        "v_sl_sls.htm#SLSLSL"
/=                                         "f_eq_sle.htm#SLEQ"
1+                                         "f_1pl_1_.htm#1PL"
1-                                         "f_1pl_1_.htm#1-"
&LT;                                       "f_eq_sle.htm#LT"
&LT;=                                      "f_eq_sle.htm#LTEQ"
=                                          "f_eq_sle.htm#EQ"
&GT;                                       "f_eq_sle.htm#GT"
&GT;=                                      "f_eq_sle.htm#GTEQ"
ABORT                                      "a_abort.htm#abort"
ABS                                        "f_abs.htm#abs"
ACONS                                      "f_acons.htm#acons"
ACOS                                       "f_asin_.htm#acos"
ACOSH                                      "f_sinh_.htm#acosh"
ADD-METHOD                                 "f_add_me.htm#add-method"
ADJOIN                                     "f_adjoin.htm#adjoin"
ADJUST-ARRAY                               "f_adjust.htm#adjust-array"
ADJUSTABLE-ARRAY-P                         "f_adju_1.htm#adjustable-array-p"
ALLOCATE-INSTANCE                          "f_alloca.htm#allocate-instance"
ALPHA-CHAR-P                               "f_alpha_.htm#alpha-char-p"
ALPHANUMERICP                              "f_alphan.htm#alphanumericp"
AND                                        "a_and.htm#and"
APPEND                                     "f_append.htm#append"
APPLY                                      "f_apply.htm#apply"
APROPOS                                    "f_apropo.htm#apropos"
APROPOS-LIST                               "f_apropo.htm#apropos-list"
AREF                                       "f_aref.htm#aref"
ARITHMETIC-ERROR                           "e_arithm.htm#arithmetic-error"
ARITHMETIC-ERROR-OPERANDS                  "f_arithm.htm#arithmetic-error-operands"
ARITHMETIC-ERROR-OPERATION                 "f_arithm.htm#arithmetic-error-operation"
ARRAY                                      "t_array.htm#array"
ARRAY-DIMENSION                            "f_ar_dim.htm#array-dimension"
ARRAY-DIMENSION-LIMIT                      "v_ar_dim.htm#array-dimension-limit"
ARRAY-DIMENSIONS                           "f_ar_d_1.htm#array-dimensions"
ARRAY-DISPLACEMENT                         "f_ar_dis.htm#array-displacement"
ARRAY-ELEMENT-TYPE                         "f_ar_ele.htm#array-element-type"
ARRAY-HAS-FILL-POINTER-P                   "f_ar_has.htm#array-has-fill-pointer-p"
ARRAY-IN-BOUNDS-P                          "f_ar_in_.htm#array-in-bounds-p"
ARRAY-RANK                                 "f_ar_ran.htm#array-rank"
ARRAY-RANK-LIMIT                           "v_ar_ran.htm#array-rank-limit"
ARRAY-ROW-MAJOR-INDEX                      "f_ar_row.htm#array-row-major-index"
ARRAY-TOTAL-SIZE                           "f_ar_tot.htm#array-total-size"
ARRAY-TOTAL-SIZE-LIMIT                     "v_ar_tot.htm#array-total-size-limit"
ARRAYP                                     "f_arrayp.htm#arrayp"
ASH                                        "f_ash.htm#ash"
ASIN                                       "f_asin_.htm#asin"
ASINH                                      "f_sinh_.htm#asinh"
ASSERT                                     "m_assert.htm#assert"
ASSOC                                      "f_assocc.htm#assoc"
ASSOC-IF                                   "f_assocc.htm#assoc-if"
ASSOC-IF-NOT                               "f_assocc.htm#assoc-if-not"
ATAN                                       "f_asin_.htm#atan"
ATANH                                      "f_sinh_.htm#atanh"
ATOM                                       "a_atom.htm#atom"
BASE-CHAR                                  "t_base_c.htm#base-char"
BASE-STRING                                "t_base_s.htm#base-string"
BIGNUM                                     "t_bignum.htm#bignum"
BIT                                        "a_bit.htm#bit"
BIT-AND                                    "f_bt_and.htm#bit-and"
BIT-ANDC1                                  "f_bt_and.htm#bit-andc1"
BIT-ANDC2                                  "f_bt_and.htm#bit-andc2"
BIT-EQV                                    "f_bt_and.htm#bit-eqv"
BIT-IOR                                    "f_bt_and.htm#bit-ior"
BIT-NAND                                   "f_bt_and.htm#bit-nand"
BIT-NOR                                    "f_bt_and.htm#bit-nor"
BIT-NOT                                    "f_bt_and.htm#bit-not"
BIT-ORC1                                   "f_bt_and.htm#bit-orc1"
BIT-ORC2                                   "f_bt_and.htm#bit-orc2"
BIT-VECTOR                                 "t_bt_vec.htm#bit-vector"
BIT-VECTOR-P                               "f_bt_vec.htm#bit-vector-p"
BIT-XOR                                    "f_bt_and.htm#bit-xor"
BLOCK                                      "s_block.htm#block"
BOOLE                                      "f_boole.htm#boole"
BOOLE-1                                    "v_b_1_b.htm#boole-1"
BOOLE-2                                    "v_b_1_b.htm#boole-2"
BOOLE-AND                                  "v_b_1_b.htm#boole-and"
BOOLE-ANDC1                                "v_b_1_b.htm#boole-andc1"
BOOLE-ANDC2                                "v_b_1_b.htm#boole-andc2"
BOOLE-C1                                   "v_b_1_b.htm#boole-c1"
BOOLE-C2                                   "v_b_1_b.htm#boole-c2"
BOOLE-CLR                                  "v_b_1_b.htm#boole-clr"
BOOLE-EQV                                  "v_b_1_b.htm#boole-eqv"
BOOLE-IOR                                  "v_b_1_b.htm#boole-ior"
BOOLE-NAND                                 "v_b_1_b.htm#boole-nand"
BOOLE-NOR                                  "v_b_1_b.htm#boole-nor"
BOOLE-ORC1                                 "v_b_1_b.htm#boole-orc1"
BOOLE-ORC2                                 "v_b_1_b.htm#boole-orc2"
BOOLE-SET                                  "v_b_1_b.htm#boole-set"
BOOLE-XOR                                  "v_b_1_b.htm#boole-xor"
BOOLEAN                                    "t_ban.htm#boolean"
BOTH-CASE-P                                "f_upper_.htm#both-case-p"
BOUNDP                                     "f_boundp.htm#boundp"
BREAK                                      "f_break.htm#break"
BROADCAST-STREAM                           "t_broadc.htm#broadcast-stream"
BROADCAST-STREAM-STREAMS                   "f_broadc.htm#broadcast-stream-streams"
BUILT-IN-CLASS                             "t_built_.htm#built-in-class"
BUTLAST                                    "f_butlas.htm#butlast"
BYTE                                       "f_by_by.htm#byte"
BYTE-POSITION                              "f_by_by.htm#byte-position"
BYTE-SIZE                                  "f_by_by.htm#byte-size"
CAAAAR                                     "f_car_c.htm#caaaar"
CAAADR                                     "f_car_c.htm#caaadr"
CAAAR                                      "f_car_c.htm#caaar"
CAADAR                                     "f_car_c.htm#caadar"
CAADDR                                     "f_car_c.htm#caaddr"
CAADR                                      "f_car_c.htm#caadr"
CAAR                                       "f_car_c.htm#caar"
CADAAR                                     "f_car_c.htm#cadaar"
CADADR                                     "f_car_c.htm#cadadr"
CADAR                                      "f_car_c.htm#cadar"
CADDAR                                     "f_car_c.htm#caddar"
CADDDR                                     "f_car_c.htm#cadddr"
CADDR                                      "f_car_c.htm#caddr"
CADR                                       "f_car_c.htm#cadr"
CALL-ARGUMENTS-LIMIT                       "v_call_a.htm#call-arguments-limit"
CALL-METHOD                                "m_call_m.htm#call-method"
CALL-NEXT-METHOD                           "f_call_n.htm#call-next-method"
CAR                                        "f_car_c.htm#car"
CASE                                       "m_case_.htm#case"
CATCH                                      "s_catch.htm#catch"
CCASE                                      "m_case_.htm#ccase"
CDAAAR                                     "f_car_c.htm#cdaaar"
CDAADR                                     "f_car_c.htm#cdaadr"
CDAAR                                      "f_car_c.htm#cdaar"
CDADAR                                     "f_car_c.htm#cdadar"
CDADDR                                     "f_car_c.htm#cdaddr"
CDADR                                      "f_car_c.htm#cdadr"
CDAR                                       "f_car_c.htm#cdar"
CDDAAR                                     "f_car_c.htm#cddaar"
CDDADR                                     "f_car_c.htm#cddadr"
CDDAR                                      "f_car_c.htm#cddar"
CDDDAR                                     "f_car_c.htm#cdddar"
CDDDDR                                     "f_car_c.htm#cddddr"
CDDDR                                      "f_car_c.htm#cdddr"
CDDR                                       "f_car_c.htm#cddr"
CDR                                        "f_car_c.htm#cdr"
CEILING                                    "f_floorc.htm#ceiling"
CELL-ERROR                                 "e_cell_e.htm#cell-error"
CELL-ERROR-NAME                            "f_cell_e.htm#cell-error-name"
CERROR                                     "f_cerror.htm#cerror"
CHANGE-CLASS                               "f_chg_cl.htm#change-class"
CHAR                                       "f_char_.htm#char"
CHAR-CODE                                  "f_char_c.htm#char-code"
CHAR-CODE-LIMIT                            "v_char_c.htm#char-code-limit"
CHAR-DOWNCASE                              "f_char_u.htm#char-downcase"
CHAR-EQUAL                                 "f_chareq.htm#char-equal"
CHAR-GREATERP                              "f_chareq.htm#char-greaterp"
CHAR-INT                                   "f_char_i.htm#char-int"
CHAR-LESSP                                 "f_chareq.htm#char-lessp"
CHAR-NAME                                  "f_char_n.htm#char-name"
CHAR-NOT-EQUAL                             "f_chareq.htm#char-not-equal"
CHAR-NOT-GREATERP                          "f_chareq.htm#char-not-greaterp"
CHAR-NOT-LESSP                             "f_chareq.htm#char-not-lessp"
CHAR-UPCASE                                "f_char_u.htm#char-upcase"
CHAR/=                                     "f_chareq.htm#charSLEQ"
CHAR&LT;                                   "f_chareq.htm#charLT"
CHAR&LT;=                                  "f_chareq.htm#charLTEQ"
CHAR=                                      "f_chareq.htm#charEQ"
CHAR&GT;                                   "f_chareq.htm#charGT"
CHAR&GT;=                                  "f_chareq.htm#charGTEQ"
CHARACTER                                  "a_ch.htm#character"
CHARACTERP                                 "f_chp.htm#characterp"
CHECK-TYPE                                 "m_check_.htm#check-type"
CIS                                        "f_cis.htm#cis"
CLASS                                      "t_class.htm#class"
CLASS-NAME                                 "f_class_.htm#class-name"
CLASS-OF                                   "f_clas_1.htm#class-of"
CLEAR-INPUT                                "f_clear_.htm#clear-input"
CLEAR-OUTPUT                               "f_finish.htm#clear-output"
CLOSE                                      "f_close.htm#close"
CLRHASH                                    "f_clrhas.htm#clrhash"
CODE-CHAR                                  "f_code_c.htm#code-char"
COERCE                                     "f_coerce.htm#coerce"
COMPILATION-SPEED                          "d_optimi.htm#compilation-speed"
COMPILE                                    "f_cmp.htm#compile"
COMPILE-FILE                               "f_cmp_fi.htm#compile-file"
COMPILE-FILE-PATHNAME                      "f_cmp__1.htm#compile-file-pathname"
COMPILED-FUNCTION                          "t_cmpd_f.htm#compiled-function"
COMPILED-FUNCTION-P                        "f_cmpd_f.htm#compiled-function-p"
COMPILER-MACRO                             "f_docume.htm#compiler-macro"
COMPILER-MACRO-FUNCTION                    "f_cmp_ma.htm#compiler-macro-function"
COMPLEMENT                                 "f_comple.htm#complement"
COMPLEX                                    "a_comple.htm#complex"
COMPLEXP                                   "f_comp_3.htm#complexp"
COMPUTE-APPLICABLE-METHODS                 "f_comput.htm#compute-applicable-methods"
COMPUTE-RESTARTS                           "f_comp_1.htm#compute-restarts"
CONCATENATE                                "f_concat.htm#concatenate"
CONCATENATED-STREAM                        "t_concat.htm#concatenated-stream"
CONCATENATED-STREAM-STREAMS                "f_conc_1.htm#concatenated-stream-streams"
COND                                       "m_cond.htm#cond"
CONDITION                                  "e_cnd.htm#condition"
CONJUGATE                                  "f_conjug.htm#conjugate"
CONS                                       "a_cons.htm#cons"
CONSP                                      "f_consp.htm#consp"
CONSTANTLY                                 "f_cons_1.htm#constantly"
CONSTANTP                                  "f_consta.htm#constantp"
CONTINUE                                   "a_contin.htm#continue"
CONTROL-ERROR                              "e_contro.htm#control-error"
COPY-ALIST                                 "f_cp_ali.htm#copy-alist"
COPY-LIST                                  "f_cp_lis.htm#copy-list"
COPY-PPRINT-DISPATCH                       "f_cp_ppr.htm#copy-pprint-dispatch"
COPY-READTABLE                             "f_cp_rdt.htm#copy-readtable"
COPY-SEQ                                   "f_cp_seq.htm#copy-seq"
COPY-STRUCTURE                             "f_cp_stu.htm#copy-structure"
COPY-SYMBOL                                "f_cp_sym.htm#copy-symbol"
COPY-TREE                                  "f_cp_tre.htm#copy-tree"
COS                                        "f_sin_c.htm#cos"
COSH                                       "f_sinh_.htm#cosh"
COUNT                                      "f_countc.htm#count"
COUNT-IF                                   "f_countc.htm#count-if"
COUNT-IF-NOT                               "f_countc.htm#count-if-not"
CTYPECASE                                  "m_tpcase.htm#ctypecase"
DEBUG                                      "d_optimi.htm#debug"
DECF                                       "m_incf_.htm#decf"
DECLAIM                                    "m_declai.htm#declaim"
DECLARATION                                "d_declar.htm#declaration"
DECLARE                                    "s_declar.htm#declare"
DECODE-FLOAT                               "f_dec_fl.htm#decode-float"
DECODE-UNIVERSAL-TIME                      "f_dec_un.htm#decode-universal-time"
DEFCLASS                                   "m_defcla.htm#defclass"
DEFCONSTANT                                "m_defcon.htm#defconstant"
DEFGENERIC                                 "m_defgen.htm#defgeneric"
DEFINE-COMPILER-MACRO                      "m_define.htm#define-compiler-macro"
DEFINE-CONDITION                           "m_defi_5.htm#define-condition"
DEFINE-METHOD-COMBINATION                  "m_defi_4.htm#define-method-combination"
DEFINE-MODIFY-MACRO                        "m_defi_2.htm#define-modify-macro"
DEFINE-SETF-EXPANDER                       "m_defi_3.htm#define-setf-expander"
DEFINE-SYMBOL-MACRO                        "m_defi_1.htm#define-symbol-macro"
DEFMACRO                                   "m_defmac.htm#defmacro"
DEFMETHOD                                  "m_defmet.htm#defmethod"
DEFPACKAGE                                 "m_defpkg.htm#defpackage"
DEFPARAMETER                               "m_defpar.htm#defparameter"
DEFSETF                                    "m_defset.htm#defsetf"
DEFSTRUCT                                  "m_defstr.htm#defstruct"
DEFTYPE                                    "m_deftp.htm#deftype"
DEFUN                                      "m_defun.htm#defun"
DEFVAR                                     "m_defpar.htm#defvar"
DELETE                                     "f_rm_rm.htm#delete"
DELETE-DUPLICATES                          "f_rm_dup.htm#delete-duplicates"
DELETE-FILE                                "f_del_fi.htm#delete-file"
DELETE-IF                                  "f_rm_rm.htm#delete-if"
DELETE-IF-NOT                              "f_rm_rm.htm#delete-if-not"
DELETE-PACKAGE                             "f_del_pk.htm#delete-package"
DENOMINATOR                                "f_numera.htm#denominator"
DEPOSIT-FIELD                              "f_deposi.htm#deposit-field"
DESCRIBE                                   "f_descri.htm#describe"
DESCRIBE-OBJECT                            "f_desc_1.htm#describe-object"
DESTRUCTURING-BIND                         "m_destru.htm#destructuring-bind"
DIGIT-CHAR                                 "f_digit_.htm#digit-char"
DIGIT-CHAR-P                               "f_digi_1.htm#digit-char-p"
DIRECTORY                                  "f_dir.htm#directory"
DIRECTORY-NAMESTRING                       "f_namest.htm#directory-namestring"
DISASSEMBLE                                "f_disass.htm#disassemble"
DIVISION-BY-ZERO                           "e_divisi.htm#division-by-zero"
DO                                         "m_do_do.htm#do"
DO*                                        "m_do_do.htm#doST"
DO-ALL-SYMBOLS                             "m_do_sym.htm#do-all-symbols"
DO-EXTERNAL-SYMBOLS                        "m_do_sym.htm#do-external-symbols"
DO-SYMBOLS                                 "m_do_sym.htm#do-symbols"
DOCUMENTATION                              "f_docume.htm#documentation"
DOLIST                                     "m_dolist.htm#dolist"
DOTIMES                                    "m_dotime.htm#dotimes"
DOUBLE-FLOAT                               "t_short_.htm#double-float"
DOUBLE-FLOAT-EPSILON                       "v_short_.htm#double-float-epsilon"
DOUBLE-FLOAT-NEGATIVE-EPSILON              "v_short_.htm#double-float-negative-epsilon"
DPB                                        "f_dpb.htm#dpb"
DRIBBLE                                    "f_dribbl.htm#dribble"
DYNAMIC-EXTENT                             "d_dynami.htm#dynamic-extent"
ECASE                                      "m_case_.htm#ecase"
ECHO-STREAM                                "t_echo_s.htm#echo-stream"
ECHO-STREAM-INPUT-STREAM                   "f_echo_s.htm#echo-stream-input-stream"
ECHO-STREAM-OUTPUT-STREAM                  "f_echo_s.htm#echo-stream-output-stream"
ED                                         "f_ed.htm#ed"
EIGHTH                                     "f_firstc.htm#eighth"
ELT                                        "f_elt.htm#elt"
ENCODE-UNIVERSAL-TIME                      "f_encode.htm#encode-universal-time"
END-OF-FILE                                "e_end_of.htm#end-of-file"
ENDP                                       "f_endp.htm#endp"
ENOUGH-NAMESTRING                          "f_namest.htm#enough-namestring"
ENSURE-DIRECTORIES-EXIST                   "f_ensu_1.htm#ensure-directories-exist"
ENSURE-GENERIC-FUNCTION                    "f_ensure.htm#ensure-generic-function"
EQ                                         "f_eq.htm#eq"
EQL                                        "a_eql.htm#eql"
EQUAL                                      "f_equal.htm#equal"
EQUALP                                     "f_equalp.htm#equalp"
ERROR                                      "a_error.htm#error"
ETYPECASE                                  "m_tpcase.htm#etypecase"
EVAL                                       "f_eval.htm#eval"
EVAL-WHEN                                  "s_eval_w.htm#eval-when"
EVENP                                      "f_evenpc.htm#evenp"
EVERY                                      "f_everyc.htm#every"
EXP                                        "f_exp_e.htm#exp"
EXPORT                                     "f_export.htm#export"
EXPT                                       "f_exp_e.htm#expt"
EXTENDED-CHAR                              "t_extend.htm#extended-char"
FBOUNDP                                    "f_fbound.htm#fboundp"
FCEILING                                   "f_floorc.htm#fceiling"
FDEFINITION                                "f_fdefin.htm#fdefinition"
FFLOOR                                     "f_floorc.htm#ffloor"
FIFTH                                      "f_firstc.htm#fifth"
FILE-AUTHOR                                "f_file_a.htm#file-author"
FILE-ERROR                                 "e_file_e.htm#file-error"
FILE-ERROR-PATHNAME                        "f_file_e.htm#file-error-pathname"
FILE-LENGTH                                "f_file_l.htm#file-length"
FILE-NAMESTRING                            "f_namest.htm#file-namestring"
FILE-POSITION                              "f_file_p.htm#file-position"
FILE-STREAM                                "t_file_s.htm#file-stream"
FILE-STRING-LENGTH                         "f_file_s.htm#file-string-length"
FILE-WRITE-DATE                            "f_file_w.htm#file-write-date"
FILL                                       "f_fill.htm#fill"
FILL-POINTER                               "f_fill_p.htm#fill-pointer"
FIND                                       "f_find_.htm#find"
FIND-ALL-SYMBOLS                           "f_find_a.htm#find-all-symbols"
FIND-CLASS                                 "f_find_c.htm#find-class"
FIND-IF                                    "f_find_.htm#find-if"
FIND-IF-NOT                                "f_find_.htm#find-if-not"
FIND-METHOD                                "f_find_m.htm#find-method"
FIND-PACKAGE                               "f_find_p.htm#find-package"
FIND-RESTART                               "f_find_r.htm#find-restart"
FIND-SYMBOL                                "f_find_s.htm#find-symbol"
FINISH-OUTPUT                              "f_finish.htm#finish-output"
FIRST                                      "f_firstc.htm#first"
FIXNUM                                     "t_fixnum.htm#fixnum"
FLET                                       "s_flet_.htm#flet"
FLOAT                                      "a_float.htm#float"
FLOAT-DIGITS                               "f_dec_fl.htm#float-digits"
FLOAT-PRECISION                            "f_dec_fl.htm#float-precision"
FLOAT-RADIX                                "f_dec_fl.htm#float-radix"
FLOAT-SIGN                                 "f_dec_fl.htm#float-sign"
FLOATING-POINT-INEXACT                     "e_floa_1.htm#floating-point-inexact"
FLOATING-POINT-INVALID-OPERATION           "e_floati.htm#floating-point-invalid-operation"
FLOATING-POINT-OVERFLOW                    "e_floa_2.htm#floating-point-overflow"
FLOATING-POINT-UNDERFLOW                   "e_floa_3.htm#floating-point-underflow"
FLOATP                                     "f_floatp.htm#floatp"
FLOOR                                      "f_floorc.htm#floor"
FMAKUNBOUND                                "f_fmakun.htm#fmakunbound"
FORCE-OUTPUT                               "f_finish.htm#force-output"
FORMAT                                     "f_format.htm#format"
FORMATTER                                  "m_format.htm#formatter"
FOURTH                                     "f_firstc.htm#fourth"
FRESH-LINE                                 "f_terpri.htm#fresh-line"
FROUND                                     "f_floorc.htm#fround"
FTRUNCATE                                  "f_floorc.htm#ftruncate"
FTYPE                                      "d_ftype.htm#ftype"
FUNCALL                                    "f_funcal.htm#funcall"
FUNCTION                                   "a_fn.htm#function"
FUNCTION-KEYWORDS                          "f_fn_kwd.htm#function-keywords"
FUNCTION-LAMBDA-EXPRESSION                 "f_fn_lam.htm#function-lambda-expression"
FUNCTIONP                                  "f_fnp.htm#functionp"
GCD                                        "f_gcd.htm#gcd"
GENERIC-FUNCTION                           "t_generi.htm#generic-function"
GENSYM                                     "f_gensym.htm#gensym"
GENTEMP                                    "f_gentem.htm#gentemp"
GET                                        "f_get.htm#get"
GET-DECODED-TIME                           "f_get_un.htm#get-decoded-time"
GET-DISPATCH-MACRO-CHARACTER               "f_set__1.htm#get-dispatch-macro-character"
GET-INTERNAL-REAL-TIME                     "f_get_in.htm#get-internal-real-time"
GET-INTERNAL-RUN-TIME                      "f_get__1.htm#get-internal-run-time"
GET-MACRO-CHARACTER                        "f_set_ma.htm#get-macro-character"
GET-OUTPUT-STREAM-STRING                   "f_get_ou.htm#get-output-stream-string"
GET-PROPERTIES                             "f_get_pr.htm#get-properties"
GET-SETF-EXPANSION                         "f_get_se.htm#get-setf-expansion"
GET-UNIVERSAL-TIME                         "f_get_un.htm#get-universal-time"
GETF                                       "f_getf.htm#getf"
GETHASH                                    "f_gethas.htm#gethash"
GO                                         "s_go.htm#go"
GRAPHIC-CHAR-P                             "f_graphi.htm#graphic-char-p"
HANDLER-BIND                               "m_handle.htm#handler-bind"
HANDLER-CASE                               "m_hand_1.htm#handler-case"
HASH-TABLE                                 "t_hash_t.htm#hash-table"
HASH-TABLE-COUNT                           "f_hash_1.htm#hash-table-count"
HASH-TABLE-P                               "f_hash_t.htm#hash-table-p"
HASH-TABLE-REHASH-SIZE                     "f_hash_2.htm#hash-table-rehash-size"
HASH-TABLE-REHASH-THRESHOLD                "f_hash_3.htm#hash-table-rehash-threshold"
HASH-TABLE-SIZE                            "f_hash_4.htm#hash-table-size"
HASH-TABLE-TEST                            "f_hash_5.htm#hash-table-test"
HOST-NAMESTRING                            "f_namest.htm#host-namestring"
IDENTITY                                   "f_identi.htm#identity"
IF                                         "s_if.htm#if"
IGNORABLE                                  "d_ignore.htm#ignorable"
IGNORE                                     "d_ignore.htm#ignore"
IGNORE-ERRORS                              "m_ignore.htm#ignore-errors"
IMAGPART                                   "f_realpa.htm#imagpart"
IMPORT                                     "f_import.htm#import"
IN-PACKAGE                                 "m_in_pkg.htm#in-package"
INCF                                       "m_incf_.htm#incf"
INITIALIZE-INSTANCE                        "f_init_i.htm#initialize-instance"
INLINE                                     "d_inline.htm#inline"
INPUT-STREAM-P                             "f_in_stm.htm#input-stream-p"
INSPECT                                    "f_inspec.htm#inspect"
INTEGER                                    "t_intege.htm#integer"
INTEGER-DECODE-FLOAT                       "f_dec_fl.htm#integer-decode-float"
INTEGER-LENGTH                             "f_intege.htm#integer-length"
INTEGERP                                   "f_inte_1.htm#integerp"
INTERACTIVE-STREAM-P                       "f_intera.htm#interactive-stream-p"
INTERN                                     "f_intern.htm#intern"
INTERNAL-TIME-UNITS-PER-SECOND             "v_intern.htm#internal-time-units-per-second"
INTERSECTION                               "f_isec_.htm#intersection"
INVALID-METHOD-ERROR                       "f_invali.htm#invalid-method-error"
INVOKE-DEBUGGER                            "f_invoke.htm#invoke-debugger"
INVOKE-RESTART                             "f_invo_1.htm#invoke-restart"
INVOKE-RESTART-INTERACTIVELY               "f_invo_2.htm#invoke-restart-interactively"
ISQRT                                      "f_sqrt_.htm#isqrt"
KEYWORD                                    "t_kwd.htm#keyword"
KEYWORDP                                   "f_kwdp.htm#keywordp"
LABELS                                     "s_flet_.htm#labels"
LAMBDA                                     "a_lambda.htm#lambda"
LAMBDA-LIST-KEYWORDS                       "v_lambda.htm#lambda-list-keywords"
LAMBDA-PARAMETERS-LIMIT                    "v_lamb_1.htm#lambda-parameters-limit"
LAST                                       "f_last.htm#last"
LCM                                        "f_lcm.htm#lcm"
LDB                                        "f_ldb.htm#ldb"
LDB-TEST                                   "f_ldb_te.htm#ldb-test"
LDIFF                                      "f_ldiffc.htm#ldiff"
LEAST-NEGATIVE-DOUBLE-FLOAT                "v_most_1.htm#least-negative-double-float"
LEAST-NEGATIVE-LONG-FLOAT                  "v_most_1.htm#least-negative-long-float"
LEAST-NEGATIVE-NORMALIZED-DOUBLE-FLOAT     "v_most_1.htm#least-negative-normalized-double-float"
LEAST-NEGATIVE-NORMALIZED-LONG-FLOAT       "v_most_1.htm#least-negative-normalized-long-float"
LEAST-NEGATIVE-NORMALIZED-SHORT-FLOAT      "v_most_1.htm#least-negative-normalized-short-float"
LEAST-NEGATIVE-NORMALIZED-SINGLE-FLOAT     "v_most_1.htm#least-negative-normalized-single-float"
LEAST-NEGATIVE-SHORT-FLOAT                 "v_most_1.htm#least-negative-short-float"
LEAST-NEGATIVE-SINGLE-FLOAT                "v_most_1.htm#least-negative-single-float"
LEAST-POSITIVE-DOUBLE-FLOAT                "v_most_1.htm#least-positive-double-float"
LEAST-POSITIVE-LONG-FLOAT                  "v_most_1.htm#least-positive-long-float"
LEAST-POSITIVE-NORMALIZED-DOUBLE-FLOAT     "v_most_1.htm#least-positive-normalized-double-float"
LEAST-POSITIVE-NORMALIZED-LONG-FLOAT       "v_most_1.htm#least-positive-normalized-long-float"
LEAST-POSITIVE-NORMALIZED-SHORT-FLOAT      "v_most_1.htm#least-positive-normalized-short-float"
LEAST-POSITIVE-NORMALIZED-SINGLE-FLOAT     "v_most_1.htm#least-positive-normalized-single-float"
LEAST-POSITIVE-SHORT-FLOAT                 "v_most_1.htm#least-positive-short-float"
LEAST-POSITIVE-SINGLE-FLOAT                "v_most_1.htm#least-positive-single-float"
LENGTH                                     "f_length.htm#length"
LET                                        "s_let_l.htm#let"
LET*                                       "s_let_l.htm#letST"
LISP-IMPLEMENTATION-TYPE                   "f_lisp_i.htm#lisp-implementation-type"
LISP-IMPLEMENTATION-VERSION                "f_lisp_i.htm#lisp-implementation-version"
LIST                                       "a_list.htm#list"
LIST*                                      "f_list_.htm#listST"
LIST-ALL-PACKAGES                          "f_list_a.htm#list-all-packages"
LIST-LENGTH                                "f_list_l.htm#list-length"
LISTEN                                     "f_listen.htm#listen"
LISTP                                      "f_listp.htm#listp"
LOAD                                       "f_load.htm#load"
LOAD-LOGICAL-PATHNAME-TRANSLATIONS         "f_ld_log.htm#load-logical-pathname-translations"
LOAD-TIME-VALUE                            "s_ld_tim.htm#load-time-value"
LOCALLY                                    "s_locall.htm#locally"
LOG                                        "f_log.htm#log"
LOGAND                                     "f_logand.htm#logand"
LOGANDC1                                   "f_logand.htm#logandc1"
LOGANDC2                                   "f_logand.htm#logandc2"
LOGBITP                                    "f_logbtp.htm#logbitp"
LOGCOUNT                                   "f_logcou.htm#logcount"
LOGEQV                                     "f_logand.htm#logeqv"
LOGICAL-PATHNAME                           "a_logica.htm#logical-pathname"
LOGICAL-PATHNAME-TRANSLATIONS              "f_logica.htm#logical-pathname-translations"
LOGIOR                                     "f_logand.htm#logior"
LOGNAND                                    "f_logand.htm#lognand"
LOGNOR                                     "f_logand.htm#lognor"
LOGNOT                                     "f_logand.htm#lognot"
LOGORC1                                    "f_logand.htm#logorc1"
LOGORC2                                    "f_logand.htm#logorc2"
LOGTEST                                    "f_logtes.htm#logtest"
LOGXOR                                     "f_logand.htm#logxor"
LONG-FLOAT                                 "t_short_.htm#long-float"
LONG-FLOAT-EPSILON                         "v_short_.htm#long-float-epsilon"
LONG-FLOAT-NEGATIVE-EPSILON                "v_short_.htm#long-float-negative-epsilon"
LONG-SITE-NAME                             "f_short_.htm#long-site-name"
LOOP                                       "m_loop.htm#loop"
LOOP-FINISH                                "m_loop_f.htm#loop-finish"
LOWER-CASE-P                               "f_upper_.htm#lower-case-p"
MACHINE-INSTANCE                           "f_mach_i.htm#machine-instance"
MACHINE-TYPE                               "f_mach_t.htm#machine-type"
MACHINE-VERSION                            "f_mach_v.htm#machine-version"
MACRO-FUNCTION                             "f_macro_.htm#macro-function"
MACROEXPAND                                "f_mexp_.htm#macroexpand"
MACROEXPAND-1                              "f_mexp_.htm#macroexpand-1"
MACROLET                                   "s_flet_.htm#macrolet"
MAKE-ARRAY                                 "f_mk_ar.htm#make-array"
MAKE-BROADCAST-STREAM                      "f_mk_bro.htm#make-broadcast-stream"
MAKE-CONCATENATED-STREAM                   "f_mk_con.htm#make-concatenated-stream"
MAKE-CONDITION                             "f_mk_cnd.htm#make-condition"
MAKE-DISPATCH-MACRO-CHARACTER              "f_mk_dis.htm#make-dispatch-macro-character"
MAKE-ECHO-STREAM                           "f_mk_ech.htm#make-echo-stream"
MAKE-HASH-TABLE                            "f_mk_has.htm#make-hash-table"
MAKE-INSTANCE                              "f_mk_ins.htm#make-instance"
MAKE-INSTANCES-OBSOLETE                    "f_mk_i_1.htm#make-instances-obsolete"
MAKE-LIST                                  "f_mk_lis.htm#make-list"
MAKE-LOAD-FORM                             "f_mk_ld_.htm#make-load-form"
MAKE-LOAD-FORM-SAVING-SLOTS                "f_mk_l_1.htm#make-load-form-saving-slots"
MAKE-METHOD                                "m_call_m.htm#make-method"
MAKE-PACKAGE                               "f_mk_pkg.htm#make-package"
MAKE-PATHNAME                              "f_mk_pn.htm#make-pathname"
MAKE-RANDOM-STATE                          "f_mk_rnd.htm#make-random-state"
MAKE-SEQUENCE                              "f_mk_seq.htm#make-sequence"
MAKE-STRING                                "f_mk_stg.htm#make-string"
MAKE-STRING-INPUT-STREAM                   "f_mk_s_1.htm#make-string-input-stream"
MAKE-STRING-OUTPUT-STREAM                  "f_mk_s_2.htm#make-string-output-stream"
MAKE-SYMBOL                                "f_mk_sym.htm#make-symbol"
MAKE-SYNONYM-STREAM                        "f_mk_syn.htm#make-synonym-stream"
MAKE-TWO-WAY-STREAM                        "f_mk_two.htm#make-two-way-stream"
MAKUNBOUND                                 "f_makunb.htm#makunbound"
MAP                                        "f_map.htm#map"
MAP-INTO                                   "f_map_in.htm#map-into"
MAPC                                       "f_mapc_.htm#mapc"
MAPCAN                                     "f_mapc_.htm#mapcan"
MAPCAR                                     "f_mapc_.htm#mapcar"
MAPCON                                     "f_mapc_.htm#mapcon"
MAPHASH                                    "f_maphas.htm#maphash"
MAPL                                       "f_mapc_.htm#mapl"
MAPLIST                                    "f_mapc_.htm#maplist"
MASK-FIELD                                 "f_mask_f.htm#mask-field"
MAX                                        "f_max_m.htm#max"
MEMBER                                     "a_member.htm#member"
MEMBER-IF                                  "f_mem_m.htm#member-if"
MEMBER-IF-NOT                              "f_mem_m.htm#member-if-not"
MERGE                                      "f_merge.htm#merge"
MERGE-PATHNAMES                            "f_merge_.htm#merge-pathnames"
METHOD                                     "t_method.htm#method"
METHOD-COMBINATION                         "a_method.htm#method-combination"
METHOD-COMBINATION-ERROR                   "f_meth_1.htm#method-combination-error"
METHOD-QUALIFIERS                          "f_method.htm#method-qualifiers"
MIN                                        "f_max_m.htm#min"
MINUSP                                     "f_minusp.htm#minusp"
MISMATCH                                   "f_mismat.htm#mismatch"
MOD                                        "a_mod.htm#mod"
MOST-NEGATIVE-DOUBLE-FLOAT                 "v_most_1.htm#most-negative-double-float"
MOST-NEGATIVE-FIXNUM                       "v_most_p.htm#most-negative-fixnum"
MOST-NEGATIVE-LONG-FLOAT                   "v_most_1.htm#most-negative-long-float"
MOST-NEGATIVE-SHORT-FLOAT                  "v_most_1.htm#most-negative-short-float"
MOST-NEGATIVE-SINGLE-FLOAT                 "v_most_1.htm#most-negative-single-float"
MOST-POSITIVE-DOUBLE-FLOAT                 "v_most_1.htm#most-positive-double-float"
MOST-POSITIVE-FIXNUM                       "v_most_p.htm#most-positive-fixnum"
MOST-POSITIVE-LONG-FLOAT                   "v_most_1.htm#most-positive-long-float"
MOST-POSITIVE-SHORT-FLOAT                  "v_most_1.htm#most-positive-short-float"
MOST-POSITIVE-SINGLE-FLOAT                 "v_most_1.htm#most-positive-single-float"
MUFFLE-WARNING                             "a_muffle.htm#muffle-warning"
MULTIPLE-VALUE-BIND                        "m_multip.htm#multiple-value-bind"
MULTIPLE-VALUE-CALL                        "s_multip.htm#multiple-value-call"
MULTIPLE-VALUE-LIST                        "m_mult_1.htm#multiple-value-list"
MULTIPLE-VALUE-PROG1                       "s_mult_1.htm#multiple-value-prog1"
MULTIPLE-VALUE-SETQ                        "m_mult_2.htm#multiple-value-setq"
MULTIPLE-VALUES-LIMIT                      "v_multip.htm#multiple-values-limit"
NAME-CHAR                                  "f_name_c.htm#name-char"
NAMESTRING                                 "f_namest.htm#namestring"
NBUTLAST                                   "f_butlas.htm#nbutlast"
NCONC                                      "f_nconc.htm#nconc"
NEXT-METHOD-P                              "f_next_m.htm#next-method-p"
NIL                                        "a_nil.htm#nil"
NINTERSECTION                              "f_isec_.htm#nintersection"
NINTH                                      "f_firstc.htm#ninth"
NO-APPLICABLE-METHOD                       "f_no_app.htm#no-applicable-method"
NO-NEXT-METHOD                             "f_no_nex.htm#no-next-method"
NOT                                        "a_not.htm#not"
NOTANY                                     "f_everyc.htm#notany"
NOTEVERY                                   "f_everyc.htm#notevery"
NOTINLINE                                  "d_inline.htm#notinline"
NRECONC                                    "f_revapp.htm#nreconc"
NREVERSE                                   "f_revers.htm#nreverse"
NSET-DIFFERENCE                            "f_set_di.htm#nset-difference"
NSET-EXCLUSIVE-OR                          "f_set_ex.htm#nset-exclusive-or"
NSTRING-CAPITALIZE                         "f_stg_up.htm#nstring-capitalize"
NSTRING-DOWNCASE                           "f_stg_up.htm#nstring-downcase"
NSTRING-UPCASE                             "f_stg_up.htm#nstring-upcase"
NSUBLIS                                    "f_sublis.htm#nsublis"
NSUBST                                     "f_substc.htm#nsubst"
NSUBST-IF                                  "f_substc.htm#nsubst-if"
NSUBST-IF-NOT                              "f_substc.htm#nsubst-if-not"
NSUBSTITUTE                                "f_sbs_s.htm#nsubstitute"
NSUBSTITUTE-IF                             "f_sbs_s.htm#nsubstitute-if"
NSUBSTITUTE-IF-NOT                         "f_sbs_s.htm#nsubstitute-if-not"
NTH                                        "f_nth.htm#nth"
NTH-VALUE                                  "m_nth_va.htm#nth-value"
NTHCDR                                     "f_nthcdr.htm#nthcdr"
NULL                                       "a_null.htm#null"
NUMBER                                     "t_number.htm#number"
NUMBERP                                    "f_nump.htm#numberp"
NUMERATOR                                  "f_numera.htm#numerator"
NUNION                                     "f_unionc.htm#nunion"
ODDP                                       "f_evenpc.htm#oddp"
OPEN                                       "f_open.htm#open"
OPEN-STREAM-P                              "f_open_s.htm#open-stream-p"
OPTIMIZE                                   "d_optimi.htm#optimize"
OR                                         "a_or.htm#or"
OTHERWISE                                  "m_case_.htm#otherwise"
OUTPUT-STREAM-P                            "f_in_stm.htm#output-stream-p"
PACKAGE                                    "t_pkg.htm#package"
PACKAGE-ERROR                              "e_pkg_er.htm#package-error"
PACKAGE-ERROR-PACKAGE                      "f_pkg_er.htm#package-error-package"
PACKAGE-NAME                               "f_pkg_na.htm#package-name"
PACKAGE-NICKNAMES                          "f_pkg_ni.htm#package-nicknames"
PACKAGE-SHADOWING-SYMBOLS                  "f_pkg_sh.htm#package-shadowing-symbols"
PACKAGE-USE-LIST                           "f_pkg_us.htm#package-use-list"
PACKAGE-USED-BY-LIST                       "f_pkg__1.htm#package-used-by-list"
PACKAGEP                                   "f_pkgp.htm#packagep"
PAIRLIS                                    "f_pairli.htm#pairlis"
PARSE-ERROR                                "e_parse_.htm#parse-error"
PARSE-INTEGER                              "f_parse_.htm#parse-integer"
PARSE-NAMESTRING                           "f_pars_1.htm#parse-namestring"
PATHNAME                                   "a_pn.htm#pathname"
PATHNAME-DEVICE                            "f_pn_hos.htm#pathname-device"
PATHNAME-DIRECTORY                         "f_pn_hos.htm#pathname-directory"
PATHNAME-HOST                              "f_pn_hos.htm#pathname-host"
PATHNAME-MATCH-P                           "f_pn_mat.htm#pathname-match-p"
PATHNAME-NAME                              "f_pn_hos.htm#pathname-name"
PATHNAME-TYPE                              "f_pn_hos.htm#pathname-type"
PATHNAME-VERSION                           "f_pn_hos.htm#pathname-version"
PATHNAMEP                                  "f_pnp.htm#pathnamep"
PEEK-CHAR                                  "f_peek_c.htm#peek-char"
PHASE                                      "f_phase.htm#phase"
PI                                         "v_pi.htm#pi"
PLUSP                                      "f_minusp.htm#plusp"
POP                                        "m_pop.htm#pop"
POSITION                                   "f_pos_p.htm#position"
POSITION-IF                                "f_pos_p.htm#position-if"
POSITION-IF-NOT                            "f_pos_p.htm#position-if-not"
PPRINT                                     "f_wr_pr.htm#pprint"
PPRINT-DISPATCH                            "f_ppr_di.htm#pprint-dispatch"
PPRINT-EXIT-IF-LIST-EXHAUSTED              "m_ppr_ex.htm#pprint-exit-if-list-exhausted"
PPRINT-FILL                                "f_ppr_fi.htm#pprint-fill"
PPRINT-INDENT                              "f_ppr_in.htm#pprint-indent"
PPRINT-LINEAR                              "f_ppr_fi.htm#pprint-linear"
PPRINT-LOGICAL-BLOCK                       "m_ppr_lo.htm#pprint-logical-block"
PPRINT-NEWLINE                             "f_ppr_nl.htm#pprint-newline"
PPRINT-POP                                 "m_ppr_po.htm#pprint-pop"
PPRINT-TAB                                 "f_ppr_ta.htm#pprint-tab"
PPRINT-TABULAR                             "f_ppr_fi.htm#pprint-tabular"
PRIN1                                      "f_wr_pr.htm#prin1"
PRIN1-TO-STRING                            "f_wr_to_.htm#prin1-to-string"
PRINC                                      "f_wr_pr.htm#princ"
PRINC-TO-STRING                            "f_wr_to_.htm#princ-to-string"
PRINT                                      "f_wr_pr.htm#print"
PRINT-NOT-READABLE                         "e_pr_not.htm#print-not-readable"
PRINT-NOT-READABLE-OBJECT                  "f_pr_not.htm#print-not-readable-object"
PRINT-OBJECT                               "f_pr_obj.htm#print-object"
PRINT-UNREADABLE-OBJECT                    "m_pr_unr.htm#print-unreadable-object"
PROBE-FILE                                 "f_probe_.htm#probe-file"
PROCLAIM                                   "f_procla.htm#proclaim"
PROG                                       "m_prog_.htm#prog"
PROG*                                      "m_prog_.htm#progST"
PROG1                                      "m_prog1c.htm#prog1"
PROG2                                      "m_prog1c.htm#prog2"
PROGN                                      "s_progn.htm#progn"
PROGRAM-ERROR                              "e_progra.htm#program-error"
PROGV                                      "s_progv.htm#progv"
PROVIDE                                    "f_provid.htm#provide"
PSETF                                      "m_setf_.htm#psetf"
PSETQ                                      "m_psetq.htm#psetq"
PUSH                                       "m_push.htm#push"
PUSHNEW                                    "m_pshnew.htm#pushnew"
QUOTE                                      "s_quote.htm#quote"
RANDOM                                     "f_random.htm#random"
RANDOM-STATE                               "t_rnd_st.htm#random-state"
RANDOM-STATE-P                             "f_rnd_st.htm#random-state-p"
RASSOC                                     "f_rassoc.htm#rassoc"
RASSOC-IF                                  "f_rassoc.htm#rassoc-if"
RASSOC-IF-NOT                              "f_rassoc.htm#rassoc-if-not"
RATIO                                      "t_ratio.htm#ratio"
RATIONAL                                   "a_ration.htm#rational"
RATIONALIZE                                "f_ration.htm#rationalize"
RATIONALP                                  "f_rati_1.htm#rationalp"
READ                                       "f_rd_rd.htm#read"
READ-BYTE                                  "f_rd_by.htm#read-byte"
READ-CHAR                                  "f_rd_cha.htm#read-char"
READ-CHAR-NO-HANG                          "f_rd_c_1.htm#read-char-no-hang"
READ-DELIMITED-LIST                        "f_rd_del.htm#read-delimited-list"
READ-FROM-STRING                           "f_rd_fro.htm#read-from-string"
READ-LINE                                  "f_rd_lin.htm#read-line"
READ-PRESERVING-WHITESPACE                 "f_rd_rd.htm#read-preserving-whitespace"
READ-SEQUENCE                              "f_rd_seq.htm#read-sequence"
READER-ERROR                               "e_rder_e.htm#reader-error"
READTABLE                                  "t_rdtabl.htm#readtable"
READTABLE-CASE                             "f_rdtabl.htm#readtable-case"
READTABLEP                                 "f_rdta_1.htm#readtablep"
REAL                                       "t_real.htm#real"
REALP                                      "f_realp.htm#realp"
REALPART                                   "f_realpa.htm#realpart"
REDUCE                                     "f_reduce.htm#reduce"
REINITIALIZE-INSTANCE                      "f_reinit.htm#reinitialize-instance"
REM                                        "f_mod_r.htm#rem"
REMF                                       "m_remf.htm#remf"
REMHASH                                    "f_remhas.htm#remhash"
REMOVE                                     "f_rm_rm.htm#remove"
REMOVE-DUPLICATES                          "f_rm_dup.htm#remove-duplicates"
REMOVE-IF                                  "f_rm_rm.htm#remove-if"
REMOVE-IF-NOT                              "f_rm_rm.htm#remove-if-not"
REMOVE-METHOD                              "f_rm_met.htm#remove-method"
REMPROP                                    "f_rempro.htm#remprop"
RENAME-FILE                                "f_rn_fil.htm#rename-file"
RENAME-PACKAGE                             "f_rn_pkg.htm#rename-package"
REPLACE                                    "f_replac.htm#replace"
REQUIRE                                    "f_provid.htm#require"
REST                                       "f_rest.htm#rest"
RESTART                                    "t_rst.htm#restart"
RESTART-BIND                               "m_rst_bi.htm#restart-bind"
RESTART-CASE                               "m_rst_ca.htm#restart-case"
RESTART-NAME                               "f_rst_na.htm#restart-name"
RETURN                                     "m_return.htm#return"
RETURN-FROM                                "s_ret_fr.htm#return-from"
REVAPPEND                                  "f_revapp.htm#revappend"
REVERSE                                    "f_revers.htm#reverse"
ROOM                                       "f_room.htm#room"
ROTATEF                                    "m_rotate.htm#rotatef"
ROUND                                      "f_floorc.htm#round"
ROW-MAJOR-AREF                             "f_row_ma.htm#row-major-aref"
RPLACA                                     "f_rplaca.htm#rplaca"
RPLACD                                     "f_rplaca.htm#rplacd"
SAFETY                                     "d_optimi.htm#safety"
SATISFIES                                  "t_satisf.htm#satisfies"
SBIT                                       "f_bt_sb.htm#sbit"
SCALE-FLOAT                                "f_dec_fl.htm#scale-float"
SCHAR                                      "f_char_.htm#schar"
SEARCH                                     "f_search.htm#search"
SECOND                                     "f_firstc.htm#second"
SEQUENCE                                   "t_seq.htm#sequence"
SERIOUS-CONDITION                          "e_seriou.htm#serious-condition"
SET                                        "f_set.htm#set"
SET-DIFFERENCE                             "f_set_di.htm#set-difference"
SET-DISPATCH-MACRO-CHARACTER               "f_set__1.htm#set-dispatch-macro-character"
SET-EXCLUSIVE-OR                           "f_set_ex.htm#set-exclusive-or"
SET-MACRO-CHARACTER                        "f_set_ma.htm#set-macro-character"
SET-PPRINT-DISPATCH                        "f_set_pp.htm#set-pprint-dispatch"
SET-SYNTAX-FROM-CHAR                       "f_set_sy.htm#set-syntax-from-char"
SETF                                       "a_setf.htm#setf"
SETQ                                       "s_setq.htm#setq"
SEVENTH                                    "f_firstc.htm#seventh"
SHADOW                                     "f_shadow.htm#shadow"
SHADOWING-IMPORT                           "f_shdw_i.htm#shadowing-import"
SHARED-INITIALIZE                          "f_shared.htm#shared-initialize"
SHIFTF                                     "m_shiftf.htm#shiftf"
SHORT-FLOAT                                "t_short_.htm#short-float"
SHORT-FLOAT-EPSILON                        "v_short_.htm#short-float-epsilon"
SHORT-FLOAT-NEGATIVE-EPSILON               "v_short_.htm#short-float-negative-epsilon"
SHORT-SITE-NAME                            "f_short_.htm#short-site-name"
SIGNAL                                     "f_signal.htm#signal"
SIGNED-BYTE                                "t_sgn_by.htm#signed-byte"
SIGNUM                                     "f_signum.htm#signum"
SIMPLE-ARRAY                               "t_smp_ar.htm#simple-array"
SIMPLE-BASE-STRING                         "t_smp_ba.htm#simple-base-string"
SIMPLE-BIT-VECTOR                          "t_smp_bt.htm#simple-bit-vector"
SIMPLE-BIT-VECTOR-P                        "f_smp_bt.htm#simple-bit-vector-p"
SIMPLE-CONDITION                           "e_smp_cn.htm#simple-condition"
SIMPLE-CONDITION-FORMAT-ARGUMENTS          "f_smp_cn.htm#simple-condition-format-arguments"
SIMPLE-CONDITION-FORMAT-CONTROL            "f_smp_cn.htm#simple-condition-format-control"
SIMPLE-ERROR                               "e_smp_er.htm#simple-error"
SIMPLE-STRING                              "t_smp_st.htm#simple-string"
SIMPLE-STRING-P                            "f_smp_st.htm#simple-string-p"
SIMPLE-TYPE-ERROR                          "e_smp_tp.htm#simple-type-error"
SIMPLE-VECTOR                              "t_smp_ve.htm#simple-vector"
SIMPLE-VECTOR-P                            "f_smp_ve.htm#simple-vector-p"
SIMPLE-WARNING                             "e_smp_wa.htm#simple-warning"
SIN                                        "f_sin_c.htm#sin"
SINGLE-FLOAT                               "t_short_.htm#single-float"
SINGLE-FLOAT-EPSILON                       "v_short_.htm#single-float-epsilon"
SINGLE-FLOAT-NEGATIVE-EPSILON              "v_short_.htm#single-float-negative-epsilon"
SINH                                       "f_sinh_.htm#sinh"
SIXTH                                      "f_firstc.htm#sixth"
SLEEP                                      "f_sleep.htm#sleep"
SLOT-BOUNDP                                "f_slt_bo.htm#slot-boundp"
SLOT-EXISTS-P                              "f_slt_ex.htm#slot-exists-p"
SLOT-MAKUNBOUND                            "f_slt_ma.htm#slot-makunbound"
SLOT-MISSING                               "f_slt_mi.htm#slot-missing"
SLOT-UNBOUND                               "f_slt_un.htm#slot-unbound"
SLOT-VALUE                                 "f_slt_va.htm#slot-value"
SOFTWARE-TYPE                              "f_sw_tpc.htm#software-type"
SOFTWARE-VERSION                           "f_sw_tpc.htm#software-version"
SOME                                       "f_everyc.htm#some"
SORT                                       "f_sort_.htm#sort"
SPACE                                      "d_optimi.htm#space"
SPECIAL                                    "d_specia.htm#special"
SPECIAL-OPERATOR-P                         "f_specia.htm#special-operator-p"
SPEED                                      "d_optimi.htm#speed"
SQRT                                       "f_sqrt_.htm#sqrt"
STABLE-SORT                                "f_sort_.htm#stable-sort"
STANDARD                                   "07_ffb.htm#standard"
STANDARD-CHAR                              "t_std_ch.htm#standard-char"
STANDARD-CHAR-P                            "f_std_ch.htm#standard-char-p"
STANDARD-CLASS                             "t_std_cl.htm#standard-class"
STANDARD-GENERIC-FUNCTION                  "t_std_ge.htm#standard-generic-function"
STANDARD-METHOD                            "t_std_me.htm#standard-method"
STANDARD-OBJECT                            "t_std_ob.htm#standard-object"
STEP                                       "m_step.htm#step"
STORAGE-CONDITION                          "e_storag.htm#storage-condition"
STORE-VALUE                                "a_store_.htm#store-value"
STREAM                                     "t_stream.htm#stream"
STREAM-ELEMENT-TYPE                        "f_stm_el.htm#stream-element-type"
STREAM-ERROR                               "e_stm_er.htm#stream-error"
STREAM-ERROR-STREAM                        "f_stm_er.htm#stream-error-stream"
STREAM-EXTERNAL-FORMAT                     "f_stm_ex.htm#stream-external-format"
STREAMP                                    "f_stmp.htm#streamp"
STRING                                     "a_string.htm#string"
STRING-CAPITALIZE                          "f_stg_up.htm#string-capitalize"
STRING-DOWNCASE                            "f_stg_up.htm#string-downcase"
STRING-EQUAL                               "f_stgeq_.htm#string-equal"
STRING-GREATERP                            "f_stgeq_.htm#string-greaterp"
STRING-LEFT-TRIM                           "f_stg_tr.htm#string-left-trim"
STRING-LESSP                               "f_stgeq_.htm#string-lessp"
STRING-NOT-EQUAL                           "f_stgeq_.htm#string-not-equal"
STRING-NOT-GREATERP                        "f_stgeq_.htm#string-not-greaterp"
STRING-NOT-LESSP                           "f_stgeq_.htm#string-not-lessp"
STRING-RIGHT-TRIM                          "f_stg_tr.htm#string-right-trim"
STRING-STREAM                              "t_stg_st.htm#string-stream"
STRING-TRIM                                "f_stg_tr.htm#string-trim"
STRING-UPCASE                              "f_stg_up.htm#string-upcase"
STRING/=                                   "f_stgeq_.htm#stringSLEQ"
STRING&LT;                                 "f_stgeq_.htm#stringLT"
STRING&LT;=                                "f_stgeq_.htm#stringLTEQ"
STRING=                                    "f_stgeq_.htm#stringEQ"
STRING&GT;                                 "f_stgeq_.htm#stringGT"
STRING&GT;=                                "f_stgeq_.htm#stringGTEQ"
STRINGP                                    "f_stgp.htm#stringp"
STRUCTURE                                  "f_docume.htm#structure"
STRUCTURE-CLASS                            "t_stu_cl.htm#structure-class"
STRUCTURE-OBJECT                           "t_stu_ob.htm#structure-object"
STYLE-WARNING                              "e_style_.htm#style-warning"
SUBLIS                                     "f_sublis.htm#sublis"
SUBSEQ                                     "f_subseq.htm#subseq"
SUBSETP                                    "f_subset.htm#subsetp"
SUBST                                      "f_substc.htm#subst"
SUBST-IF                                   "f_substc.htm#subst-if"
SUBST-IF-NOT                               "f_substc.htm#subst-if-not"
SUBSTITUTE                                 "f_sbs_s.htm#substitute"
SUBSTITUTE-IF                              "f_sbs_s.htm#substitute-if"
SUBSTITUTE-IF-NOT                          "f_sbs_s.htm#substitute-if-not"
SUBTYPEP                                   "f_subtpp.htm#subtypep"
SVREF                                      "f_svref.htm#svref"
SXHASH                                     "f_sxhash.htm#sxhash"
SYMBOL                                     "t_symbol.htm#symbol"
SYMBOL-FUNCTION                            "f_symb_1.htm#symbol-function"
SYMBOL-MACROLET                            "s_symbol.htm#symbol-macrolet"
SYMBOL-NAME                                "f_symb_2.htm#symbol-name"
SYMBOL-PACKAGE                             "f_symb_3.htm#symbol-package"
SYMBOL-PLIST                               "f_symb_4.htm#symbol-plist"
SYMBOL-VALUE                               "f_symb_5.htm#symbol-value"
SYMBOLP                                    "f_symbol.htm#symbolp"
SYNONYM-STREAM                             "t_syn_st.htm#synonym-stream"
SYNONYM-STREAM-SYMBOL                      "f_syn_st.htm#synonym-stream-symbol"
T                                          "a_t.htm#t"
TAGBODY                                    "s_tagbod.htm#tagbody"
TAILP                                      "f_ldiffc.htm#tailp"
TAN                                        "f_sin_c.htm#tan"
TANH                                       "f_sinh_.htm#tanh"
TENTH                                      "f_firstc.htm#tenth"
TERPRI                                     "f_terpri.htm#terpri"
THE                                        "s_the.htm#the"
THIRD                                      "f_firstc.htm#third"
THROW                                      "s_throw.htm#throw"
TIME                                       "m_time.htm#time"
TRACE                                      "m_tracec.htm#trace"
TRANSLATE-LOGICAL-PATHNAME                 "f_tr_log.htm#translate-logical-pathname"
TRANSLATE-PATHNAME                         "f_tr_pn.htm#translate-pathname"
TREE-EQUAL                                 "f_tree_e.htm#tree-equal"
TRUENAME                                   "f_tn.htm#truename"
TRUNCATE                                   "f_floorc.htm#truncate"
TWO-WAY-STREAM                             "t_two_wa.htm#two-way-stream"
TWO-WAY-STREAM-INPUT-STREAM                "f_two_wa.htm#two-way-stream-input-stream"
TWO-WAY-STREAM-OUTPUT-STREAM               "f_two_wa.htm#two-way-stream-output-stream"
TYPE                                       "a_type.htm#type"
TYPE-ERROR                                 "e_tp_err.htm#type-error"
TYPE-ERROR-DATUM                           "f_tp_err.htm#type-error-datum"
TYPE-ERROR-EXPECTED-TYPE                   "f_tp_err.htm#type-error-expected-type"
TYPE-OF                                    "f_tp_of.htm#type-of"
TYPECASE                                   "m_tpcase.htm#typecase"
TYPEP                                      "f_typep.htm#typep"
UNBOUND-SLOT                               "e_unboun.htm#unbound-slot"
UNBOUND-SLOT-INSTANCE                      "f_unboun.htm#unbound-slot-instance"
UNBOUND-VARIABLE                           "e_unbo_1.htm#unbound-variable"
UNDEFINED-FUNCTION                         "e_undefi.htm#undefined-function"
UNEXPORT                                   "f_unexpo.htm#unexport"
UNINTERN                                   "f_uninte.htm#unintern"
UNION                                      "f_unionc.htm#union"
UNLESS                                     "m_when_.htm#unless"
UNREAD-CHAR                                "f_unrd_c.htm#unread-char"
UNSIGNED-BYTE                              "t_unsgn_.htm#unsigned-byte"
UNTRACE                                    "m_tracec.htm#untrace"
UNUSE-PACKAGE                              "f_unuse_.htm#unuse-package"
UNWIND-PROTECT                             "s_unwind.htm#unwind-protect"
UPDATE-INSTANCE-FOR-DIFFERENT-CLASS        "f_update.htm#update-instance-for-different-class"
UPDATE-INSTANCE-FOR-REDEFINED-CLASS        "f_upda_1.htm#update-instance-for-redefined-class"
UPGRADED-ARRAY-ELEMENT-TYPE                "f_upgr_1.htm#upgraded-array-element-type"
UPGRADED-COMPLEX-PART-TYPE                 "f_upgrad.htm#upgraded-complex-part-type"
UPPER-CASE-P                               "f_upper_.htm#upper-case-p"
USE-PACKAGE                                "f_use_pk.htm#use-package"
USE-VALUE                                  "a_use_va.htm#use-value"
USER-HOMEDIR-PATHNAME                      "f_user_h.htm#user-homedir-pathname"
VALUES                                     "a_values.htm#values"
VALUES-LIST                                "f_vals_l.htm#values-list"
VARIABLE                                   "f_docume.htm#variable"
VECTOR                                     "a_vector.htm#vector"
VECTOR-POP                                 "f_vec_po.htm#vector-pop"
VECTOR-PUSH                                "f_vec_ps.htm#vector-push"
VECTOR-PUSH-EXTEND                         "f_vec_ps.htm#vector-push-extend"
VECTORP                                    "f_vecp.htm#vectorp"
WARN                                       "f_warn.htm#warn"
WARNING                                    "e_warnin.htm#warning"
WHEN                                       "m_when_.htm#when"
WILD-PATHNAME-P                            "f_wild_p.htm#wild-pathname-p"
WITH-ACCESSORS                             "m_w_acce.htm#with-accessors"
WITH-COMPILATION-UNIT                      "m_w_comp.htm#with-compilation-unit"
WITH-CONDITION-RESTARTS                    "m_w_cnd_.htm#with-condition-restarts"
WITH-HASH-TABLE-ITERATOR                   "m_w_hash.htm#with-hash-table-iterator"
WITH-INPUT-FROM-STRING                     "m_w_in_f.htm#with-input-from-string"
WITH-OPEN-FILE                             "m_w_open.htm#with-open-file"
WITH-OPEN-STREAM                           "m_w_op_1.htm#with-open-stream"
WITH-OUTPUT-TO-STRING                      "m_w_out_.htm#with-output-to-string"
WITH-PACKAGE-ITERATOR                      "m_w_pkg_.htm#with-package-iterator"
WITH-SIMPLE-RESTART                        "m_w_smp_.htm#with-simple-restart"
WITH-SLOTS                                 "m_w_slts.htm#with-slots"
WITH-STANDARD-IO-SYNTAX                    "m_w_std_.htm#with-standard-io-syntax"
WRITE                                      "f_wr_pr.htm#write"
WRITE-BYTE                                 "f_wr_by.htm#write-byte"
WRITE-CHAR                                 "f_wr_cha.htm#write-char"
WRITE-LINE                                 "f_wr_stg.htm#write-line"
WRITE-SEQUENCE                             "f_wr_seq.htm#write-sequence"
WRITE-STRING                               "f_wr_stg.htm#write-string"
WRITE-TO-STRING                            "f_wr_to_.htm#write-to-string"
Y-OR-N-P                                   "f_y_or_n.htm#y-or-n-p"
YES-OR-NO-P                                "f_y_or_n.htm#yes-or-no-p"
ZEROP                                      "f_zerop.htm#zerop"
	)))


(do ((x 0 (+ x 2)))
	((= x (length hyperspec-refs)))
	(setf (getf (gethash (elt hyperspec-refs x) cl::*documentation-registry*) ':hyperspec)
		(elt hyperspec-refs (+ x 1))))

(setq hyperspec-refs nil)
(defparameter *hyperspec-loaded* t) ; defined in "misc-features.lisp"

